diff options
Diffstat (limited to 'libs/type_traits')
433 files changed, 54829 insertions, 0 deletions
diff --git a/libs/type_traits/cxx_type_traits.htm b/libs/type_traits/cxx_type_traits.htm new file mode 100644 index 0000000000..4022212780 --- /dev/null +++ b/libs/type_traits/cxx_type_traits.htm @@ -0,0 +1,19 @@ +<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> +<html> + <head> + <meta http-equiv="refresh" content="0; URL=doc/html/boost_typetraits/background.html"> + <!-- boostinspect:nounlinked --> + </head> + <body><P> + Automatic redirection failed, please go to + <a href="doc/html/boost_typetraits/background.html">doc/html/boost_typetraits/background.html.</a></P> + <P>Copyright John Maddock 2006</P> + <P>Distributed under the Boost Software License, Version 1.0. (See accompanying file <A href="../../LICENSE_1_0.txt"> + LICENSE_1_0.txt</A> or copy at <A href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</A>).</P> + </body> +</html> + + + + + diff --git a/libs/type_traits/doc/Jamfile.v2 b/libs/type_traits/doc/Jamfile.v2 new file mode 100644 index 0000000000..67398ee92c --- /dev/null +++ b/libs/type_traits/doc/Jamfile.v2 @@ -0,0 +1,72 @@ + +# Copyright John Maddock 2005. 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) + +import modules ; +using quickbook ; +using auto-index ; + +path-constant boost-images : ../../../doc/src/images ; +path-constant here : . ; + +xml type_traits : type_traits.qbk ; +boostbook standalone + : + type_traits + : + # Index generation: + # Path for links to Boost: + <xsl:param>boost.root=../../../.. + + # Some general style settings: + <xsl:param>table.footnote.number.format=1 + <xsl:param>footnote.number.format=1 + + # HTML options first: + # Use graphics not text for navigation: + <xsl:param>navig.graphics=1 + # How far down we chunk nested sections, basically all of them: + <xsl:param>chunk.section.depth=10 + # Don't put the first section on the same page as the TOC: + <xsl:param>chunk.first.sections=1 + # How far down sections get TOC's + <xsl:param>toc.section.depth=10 + # Max depth in each TOC: + <xsl:param>toc.max.depth=4 + # How far down we go with TOC's + <xsl:param>generate.section.toc.level=10 + + # PDF Options: + # TOC Generation: this is needed for FOP-0.9 and later: + <xsl:param>fop1.extensions=0 + <xsl:param>xep.extensions=1 + # TOC generation: this is needed for FOP 0.2, but must not be set to zero for FOP-0.9! + <xsl:param>fop.extensions=0 + # No indent on body text: + <xsl:param>body.start.indent=0pt + # Margin size: + <xsl:param>page.margin.inner=0.5in + # Margin size: + <xsl:param>page.margin.outer=0.5in + # Paper type = A4 + <xsl:param>paper.type=A4 + # Yes, we want graphics for admonishments: + <xsl:param>admon.graphics=1 + # Set this one for PDF generation *only*: + # default pnd graphics are awful in PDF form, + # better use SVG's instead: + <format>pdf:<xsl:param>admon.graphics.extension=".svg" + <format>pdf:<xsl:param>admon.graphics.path=$(boost-images)/ + <format>pdf:<xsl:param>boost.url.prefix=http://www.boost.org/doc/libs/release/libs/type_traits/doc/html + <format>pdf:<auto-index-internal>off + <format>html:<auto-index-internal>on + <auto-index-script>$(here)/index.idx + <auto-index-prefix>$(here)/../../.. + <auto-index>on + ; + +install pdf-install : standalone : <install-type>PDF <location>. <name>type_traits.pdf ; + + + diff --git a/libs/type_traits/doc/add_const.qbk b/libs/type_traits/doc/add_const.qbk new file mode 100644 index 0000000000..ec8ed1d337 --- /dev/null +++ b/libs/type_traits/doc/add_const.qbk @@ -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] + diff --git a/libs/type_traits/doc/add_cv.qbk b/libs/type_traits/doc/add_cv.qbk new file mode 100644 index 0000000000..93c9e24bac --- /dev/null +++ b/libs/type_traits/doc/add_cv.qbk @@ -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] + diff --git a/libs/type_traits/doc/add_lvalue_reference.qbk b/libs/type_traits/doc/add_lvalue_reference.qbk new file mode 100644 index 0000000000..4416816053 --- /dev/null +++ b/libs/type_traits/doc/add_lvalue_reference.qbk @@ -0,0 +1,47 @@ +[/ + Copyright 2010 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_lvalue_reference add_lvalue_reference] + + template <class T> + struct add_lvalue_reference + { + typedef __below type; + }; + +__type If `T` names an object or function type then the member typedef `type` +shall name `T&`; otherwise, if `T` names a type ['rvalue reference to U] then +the member typedef type shall name `U&`; otherwise, type shall name `T`. + +__std_ref 20.7.6.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_lvalue_reference.hpp>` or ` #include <boost/type_traits.hpp>` + +[table Examples + +[ [Expression] [Result Type]] + +[[`add_lvalue_reference<int>::type`][`int&`]] + +[[`add_lvalue_reference<int const&>::type`] [`int const&`]] + +[[`add_lvalue_reference<int*>::type`] [`int*&`]] + +[[`add_lvalue_reference<int*&>::type`] [`int*&`]] + +[[`add_lvalue_reference<int&&>::type`][`int&`]] + +[[`add_lvalue_reference<void>::type`][`void`]] + +] + +[endsect] + diff --git a/libs/type_traits/doc/add_pointer.qbk b/libs/type_traits/doc/add_pointer.qbk new file mode 100644 index 0000000000..55ea0aa2ff --- /dev/null +++ b/libs/type_traits/doc/add_pointer.qbk @@ -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] + diff --git a/libs/type_traits/doc/add_reference.qbk b/libs/type_traits/doc/add_reference.qbk new file mode 100644 index 0000000000..a36e59d7c2 --- /dev/null +++ b/libs/type_traits/doc/add_reference.qbk @@ -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:add_reference add_reference] + +[note This trait has been made obsolete by __add_lvalue_reference and __add_rvalue_reference, +and new code should use these new traits rather than __is_reference which is retained +for backwards compatibility only. +] + + + 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] + diff --git a/libs/type_traits/doc/add_rvalue_reference.qbk b/libs/type_traits/doc/add_rvalue_reference.qbk new file mode 100644 index 0000000000..e3f561bb0c --- /dev/null +++ b/libs/type_traits/doc/add_rvalue_reference.qbk @@ -0,0 +1,50 @@ +[/ + Copyright 2010 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_rvalue_reference add_rvalue_reference] + + template <class T> + struct add_rvalue_reference + { + typedef __below type; + }; + +__type If `T` names an object or function type then the member typedef type +shall name `T&&`; otherwise, type shall name `T`. ['\[Note: This rule reflects +the semantics of reference collapsing. For example, when a type `T` names +a type U&, the type `add_rvalue_reference<T>::type` is not an rvalue +reference. -end note\]]. + +__std_ref 20.7.6.2. + +__compat If the compiler does not support partial specialization of class-templates +and rvalue references +then this template will compile, but the member `type` will always be the same as +type `T`. + +__header ` #include <boost/type_traits/add_rvalue_reference.hpp>` or ` #include <boost/type_traits.hpp>` + +[table Examples + +[ [Expression] [Result Type]] + +[[`add_rvalue_reference<int>::type`][`int&&`]] + +[[`add_rvalue_reference<int const&>::type`] [`int const&`]] + +[[`add_rvalue_reference<int*>::type`] [`int*&&`]] + +[[`add_rvalue_reference<int*&>::type`] [`int*&`]] + +[[`add_rvalue_reference<int&&>::type`][`int&&`]] + +[[`add_rvalue_reference<void>::type`][`void`]] + +] + +[endsect] + diff --git a/libs/type_traits/doc/add_volatile.qbk b/libs/type_traits/doc/add_volatile.qbk new file mode 100644 index 0000000000..1157088544 --- /dev/null +++ b/libs/type_traits/doc/add_volatile.qbk @@ -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] + diff --git a/libs/type_traits/doc/aligned_storage.qbk b/libs/type_traits/doc/aligned_storage.qbk new file mode 100644 index 0000000000..582e39a3ad --- /dev/null +++ b/libs/type_traits/doc/aligned_storage.qbk @@ -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] + diff --git a/libs/type_traits/doc/alignment_of.qbk b/libs/type_traits/doc/alignment_of.qbk new file mode 100644 index 0000000000..97c6bf3c0c --- /dev/null +++ b/libs/type_traits/doc/alignment_of.qbk @@ -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] + diff --git a/libs/type_traits/doc/alignment_traits.qbk b/libs/type_traits/doc/alignment_traits.qbk new file mode 100644 index 0000000000..56a133c144 --- /dev/null +++ b/libs/type_traits/doc/alignment_traits.qbk @@ -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] + diff --git a/libs/type_traits/doc/background.qbk b/libs/type_traits/doc/background.qbk new file mode 100644 index 0000000000..11ce618071 --- /dev/null +++ b/libs/type_traits/doc/background.qbk @@ -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 +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] + + diff --git a/libs/type_traits/doc/common_type.qbk b/libs/type_traits/doc/common_type.qbk new file mode 100644 index 0000000000..1d31ec1cd1 --- /dev/null +++ b/libs/type_traits/doc/common_type.qbk @@ -0,0 +1,227 @@ +[/ + Copyright 2008 Howard Hinnant + Copyright 2008 Beman Dawes + Copyright 2010 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:common_type common_type] +[/===================================================================] + +[def __declval [@../../../utility/doc/html/declval.html declval]] + + +__header ` #include <boost/type_traits/common_type.hpp>` or ` #include <boost/type_traits.hpp>` + + namespace boost { + template <class ...T> struct __common_type; + } + + +__common_type is a traits class used to deduce a type common to a several types, useful as the return type of functions +operating on multiple input types such as in mixed-mode arithmetic.. + +The nested typedef `::type` could be defined as follows: + + template <class ...T> + struct common_type; + + template <class T, class U, class ...V> + struct common_type<T,U,...V> { + typedef typename __common_type<typename __common_type<T, U>::type, V...>::type type; + }; + + template <class T> + struct common_type<T> { + typedef T type; + }; + + template <class T, class U> + struct common_type<T, U> { + typedef decltype(__declval<bool>() ? __declval<T>() : __declval<U>()) type; + }; + +All parameter types must be complete. This trait is permitted to be specialized by a user if at least one +template parameter is a user-defined type. [*Note:] Such specializations are required when only explicit conversions +are desired among the __common_type arguments. + +Note that when the compiler does not support variadic templates (and the macro BOOST_NO_VARIADIC_TEMPLATES is defined) +then the maximum number of template arguments is 3. + + +[h4 Configuration macros] + +When the compiler does not support static assertions then the user can select the way static assertions are reported. Define + +* BOOST_COMMON_TYPE_USES_STATIC_ASSERT: define it if you want to use Boost.StaticAssert +* BOOST_COMMON_TYPE_USES_MPL_ASSERT: define it if you want to use Boost.MPL static asertions + +The default behavior is to use mpl assertions in this case, but setting BOOST_COMMON_TYPE_USES_STATIC_ASSERT may reduce +compile times and header dependencies somewhat. + +Depending on the static assertion used you will have an hint of the failing assertion either through the symbol or through the text. + +When possible common_type is implemented using `decltype`. Otherwise when BOOST_COMMON_TYPE_DONT_USE_TYPEOF is not defined +it uses Boost.TypeOf. + +[h4 Tutorial] + +In a nutshell, __common_type is a trait that takes 1 or more types, and returns a type which +all of the types will convert to. The default definition demands this conversion be implicit. +However the trait can be specialized for user-defined types which want to limit their inter-type conversions to explicit, +and yet still want to interoperate with the __common_type facility. + +[*Example:] + + template <class T, class U> + complex<typename __common_type<T, U>::type> + operator+(complex<T>, complex<U>); + + +In the above example, "mixed-mode" complex arithmetic is allowed. The return type is described by __common_type. +For example the resulting type of adding a `complex<float>` and `complex<double>` might be a `complex<double>`. + +Here is how someone might produce a variadic comparison function: + + template <class ...T> + typename __common_type<T...>::type + min(T... t); + +This is a very useful and broadly applicable utility. + +[h4 How to get the common type of types with explicit conversions?] + +Another choice for the author of the preceding operator could be + + template <class T, class U> + typename __common_type<complex<T>, complex<U> >::type + operator+(complex<T>, complex<U>); + +As the default definition of __common_type demands the conversion be implicit, we need to specialize the trait for complex types as follows. + + template <class T, class U> + struct __common_type<complex<T>, complex<U> > { + typedef complex< __common_type<T, U> > type; + }; + +[h4 How important is the order of the common_type<> template arguments?] + +The order of the template parameters is important. + +`common_type<A,B,C>::type` is not equivalent to `common_type<C,A,B>::type`, but to `common_type<common_type<A,B>::type, C>::type`. + +Consider + + struct A {}; + struct B {}; + struct C { + C() {} + C(A const&) {} + C(B const&) {} + C& operator=(C const&) { + return *this; + } + }; + +The following doesn't compile + + typedef boost::common_type<A, B, C>::type ABC; // Does not compile + +while + + typedef boost::common_type<C, A, B>::type ABC; + +compiles. + +Thus, as `common_type<A,B>::type` is undefined, `common_type<A,B,C>::type` is also undefined. + +It is intended that clients who wish for `common_type<A, B>` to be well +defined to define it themselves: + + namespace boost + { + + template <> + struct common_type<A, B> {typedef C type;}; + + } + +Now this client can ask for `common_type<A, B, C>` (and get +the same answer). + +Clients wanting to ask `common_type<A, B, C>` in any order and get the same result need to add in addition: + + namespace boost + { + + template <> struct common_type<B, A> + : public common_type<A, B> {}; + + } + +This is needed as the specialization of `common_type<A, B>` is not be used implicitly for `common_type<B, A>`. + +[h4 Can the common_type of two types be a third type?] + +Given the preceding example, one might expect `common_type<A,B>::type` to be `C` without any intervention from the user. +But the default `common_type<>` implementation doesn't grant that. It is intended that clients who wish for `common_type<A, B>` +to be well defined to define it themselves: + + namespace boost + { + + template <> + struct common_type<A, B> {typedef C type;}; + + template <> struct common_type<B, A> + : public common_type<A, B> {}; + + } + +Now this client can ask for `common_type<A, B>`. + +[h4 How common_type behaves with pointers?] + +Consider + + struct C { }: + struct B : C { }; + struct A : C { }; + + +Shouldn't `common_type<A*,B*>::type` be `C*`? I would say yes, but the default implementation will make it ill-formed. + +The library could add a specialization for pointers, as + + namespace boost + { + + template <typename A, typename B> + struct common_type<A*, B*> { + typedef common_type<A, B>* type; + }; + } + +But in the absence of a motivating use cases, we prefer not to add more than the standard specifies. + +Of course the user can always make this specialization. + +[h4 Can you explain the pros/cons of common_type against Boost.Typeof?] + +Even if they appear to be close, `__common_type` and `typeof` have +different purposes. You use `typeof` to get the type of an expression, while +you use __common_type to set explicitly the type returned of a template +function. Both are complementary, and indeed __common_type is equivalent to +`decltype(__declval<bool>() ? __declval<T>() : __declval<U>())` + +__common_type is also similar to promote_args<class ...T> in boost/math/tools/promotion.hpp, +though it is not exactly the same as promote_args either. __common_type<T1, T2>::type simply represents the result of some +operation on T1 and T2, and defaults to the type obtained by putting T1 and T2 into a conditional statement. + +It is meant to be customizable (via specialization) if this default is not appropriate. + +[endsect] + diff --git a/libs/type_traits/doc/conditional.qbk b/libs/type_traits/doc/conditional.qbk new file mode 100644 index 0000000000..edb7645718 --- /dev/null +++ b/libs/type_traits/doc/conditional.qbk @@ -0,0 +1,24 @@ +[/ + Copyright 2010 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:conditional conditional] +[/===================================================================] + + +__header ` #include <boost/type_traits/conditional.hpp>` or ` #include <boost/type_traits.hpp>` + + namespace boost { + template <bool B, class T, class U> struct __conditional; + } + +If B is true, the member typedef type shall equal T. If B is false, the member typedef type shall equal U. + +This trait is really just an alias for `boost::mpl::if_c`. + +[endsect] + diff --git a/libs/type_traits/doc/credits.qbk b/libs/type_traits/doc/credits.qbk new file mode 100644 index 0000000000..39eef4b8b1 --- /dev/null +++ b/libs/type_traits/doc/credits.qbk @@ -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 +[@../../../../doc/html/quickbook.html Boost.Quickbook] +and [@../../../../doc/html/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] + diff --git a/libs/type_traits/doc/decay.qbk b/libs/type_traits/doc/decay.qbk new file mode 100644 index 0000000000..d15e933be8 --- /dev/null +++ b/libs/type_traits/doc/decay.qbk @@ -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>::type*`, 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[3]*`]] + +[[`decay<int(&)[2]>::type`] [`int*`]] + +[[`decay<int(&)(double)>::type`] [`int(*)(double)`]] + +[[`int(*)(double`] [`int(*)(double)`]] +[[`int(double)`] [`int(*)(double)`]] + +] + +[endsect] + diff --git a/libs/type_traits/doc/decomposing_func.qbk b/libs/type_traits/doc/decomposing_func.qbk new file mode 100644 index 0000000000..4ddf5ca155 --- /dev/null +++ b/libs/type_traits/doc/decomposing_func.qbk @@ -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] + diff --git a/libs/type_traits/doc/examples.qbk b/libs/type_traits/doc/examples.qbk new file mode 100644 index 0000000000..fdcfb74b34 --- /dev/null +++ b/libs/type_traits/doc/examples.qbk @@ -0,0 +1,237 @@ +[/ + 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 [@../../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&) + { + memmove(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 [@../../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 [@../../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 [@../../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/html/boost_numericconversion/definitions.html#boost_numericconversion.definitions.numeric_types +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] + +[section:improved_min Improving std::min with common_type] + +An improved `std::min` function could be written like this: + + template <class T, class U> + typename __common_type<T, U>::type min(T t, T u) + { + return t < u ? t : u; + } + +And now expressions such as: + + min(1, 2.0) + +will actually compile and return the correct type! + +[endsect] +[endsect] + diff --git a/libs/type_traits/doc/extent.qbk b/libs/type_traits/doc/extent.qbk new file mode 100644 index 0000000000..d2a77a908b --- /dev/null +++ b/libs/type_traits/doc/extent.qbk @@ -0,0 +1,48 @@ +[/ + 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 dimension of type `T`. + +If `T` is not a (built-in) 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], 0>::type` is the type `__integral_constant<std::size_t, 2>`.] + +[:`extent<double[2][3][4], 1>::type` is the type `__integral_constant<std::size_t, 3>`.] + +[:`extent<double[2][3][4], 3>::type` is the type `__integral_constant<std::size_t, 4>`.] + +[:`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<boost::array<int, 3> >::value` is an integral constant +expression that evaluates to /0/: `boost::array` is a class type and [*not an array type]!] + +[:`extent<T>::value_type` is the type `std::size_t`.] + +[endsect] + diff --git a/libs/type_traits/doc/floating_point_promotion.qbk b/libs/type_traits/doc/floating_point_promotion.qbk new file mode 100644 index 0000000000..bbbdc7a9dc --- /dev/null +++ b/libs/type_traits/doc/floating_point_promotion.qbk @@ -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] + diff --git a/libs/type_traits/doc/function_traits.qbk b/libs/type_traits/doc/function_traits.qbk new file mode 100644 index 0000000000..1d2b3648c1 --- /dev/null +++ b/libs/type_traits/doc/function_traits.qbk @@ -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 F> + 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 `F` 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<F>::arity`] + [An integral constant expression that gives the number of arguments accepted by the function type `F`.]] +[[`function_traits<F>::result_type`] + [The type returned by function type `F`.]] +[[`function_traits<F>::__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 `arg5_type` since there are only four arguments.]] +[[`function_traits<long (*)(void)>::arity`] [A compiler error: argument type is a /function pointer/, and not a /function type/.]] + +] + +[endsect] + diff --git a/libs/type_traits/doc/has_bit_and.qbk b/libs/type_traits/doc/has_bit_and.qbk new file mode 100644 index 0000000000..48921252a8 --- /dev/null +++ b/libs/type_traits/doc/has_bit_and.qbk @@ -0,0 +1,109 @@ +[/ + (C) Copyright 2009-2011 Frederic Bron. + 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_bit_and has_bit_and] + template <class Lhs, class Rhs=Lhs, class Ret=dont_care> + struct has_bit_and : public __tof {}; + +__inherit +If (i) `lhs` of type `Lhs` and `rhs` of type `Rhs` can be used in expression `lhs&rhs`, +and (ii) `Ret=dont_care` or the result of expression `lhs&rhs` is convertible to `Ret` +then inherits from __true_type, +otherwise inherits from __false_type. + +The default behaviour (`Ret=dont_care`) is to not check for the return value of binary `operator&`. +If `Ret` is different from the default `dont_care` type, the return value is checked to be convertible to `Ret`. +Convertible to `Ret` means that the return value of the operator can be used as argument to a function expecting `Ret`: +`` +void f(Ret); +Lhs lhs; +Rhs rhs; +f(lhs&rhs); // is valid if has_bit_and<Lhs, Rhs, Ret>::value==true +`` +If `Ret=void`, the return type is checked to be exactly `void`. + +__header `#include <boost/type_traits/has_bit_and.hpp>` or `#include <boost/type_traits/has_operator.hpp>` or `#include <boost/type_traits.hpp>` + +__examples + +[:`has_bit_and<Lhs, Rhs, Ret>::value_type` is the type `bool`.] +[:`has_bit_and<Lhs, Rhs, Ret>::value` is a `bool` integral constant expression.] +[:`has_bit_and<int>::value` is a `bool` integral constant expression that evaluates to `true`.] +[:`has_bit_and<long>` inherits from `__true_type`.] + +[:`has_bit_and<int, int, int>` inherits from `__true_type`.] +[:`has_bit_and<const int, int>` inherits from `__true_type`.] + +[:`has_bit_and<int, double, bool>` inherits from `__false_type`.] +[:`has_bit_and<int, int, std::string>` inherits from `__false_type`.] + + +[*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits] + +[*Limitation:] + +* Requires a compiler with working SFINAE. + +[*Known issues:] + +* This trait cannot detect whether binary `operator&` is public or not: +if `operator&` is defined as a private member of `Lhs` then +instantiating `has_bit_and<Lhs>` will produce a compiler error. +For this reason `has_bit_and` cannot be used to determine whether a type has a public `operator&` or not. +`` +struct A { private: void operator&(const A&); }; +boost::has_bit_and<A>::value; // error: A::operator&(const A&) is private +`` + +* There is an issue if the operator exists only for type `A` and `B` is +convertible to `A`. In this case, the compiler will report an ambiguous overload. +`` +struct A { }; +void operator&(const A&, const A&); +struct B { operator A(); }; +boost::has_bit_and<A>::value; // this is fine +boost::has_bit_and<B>::value; // error: ambiguous overload +`` + +* There is an issue when applying this trait to template classes. +If `operator&` is defined but does not bind for a given template type, +it is still detected by the trait which returns `true` instead of `false`. +Example: +`` +#include <boost/type_traits/has_bit_and.hpp> +#include <iostream> + +template <class T> +struct contains { T data; }; + +template <class T> +bool operator&(const contains<T> &lhs, const contains<T> &rhs) { + return f(lhs.data, rhs.data); +} + +class bad { }; +class good { }; +bool f(const good&, const good&) { } + +int main() { + std::cout<<std::boolalpha; + // works fine for contains<good> + std::cout<<boost::has_bit_and< contains< good > >::value<<'\n'; // true + contains<good> g; + g&g; // ok + // does not work for contains<bad> + std::cout<<boost::has_bit_and< contains< bad > >::value<<'\n'; // true, should be false + contains<bad> b; + b&b; // compile time error + return 0; +} +`` + +* `volatile` qualifier is not properly handled and would lead to undefined behavior + +[endsect] + diff --git a/libs/type_traits/doc/has_bit_and_assign.qbk b/libs/type_traits/doc/has_bit_and_assign.qbk new file mode 100644 index 0000000000..382b345999 --- /dev/null +++ b/libs/type_traits/doc/has_bit_and_assign.qbk @@ -0,0 +1,109 @@ +[/ + (C) Copyright 2009-2011 Frederic Bron. + 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_bit_and_assign has_bit_and_assign] + template <class Lhs, class Rhs=Lhs, class Ret=dont_care> + struct has_bit_and_assign : public __tof {}; + +__inherit +If (i) `lhs` of type `Lhs` and `rhs` of type `Rhs` can be used in expression `lhs&=rhs`, +and (ii) `Ret=dont_care` or the result of expression `lhs&=rhs` is convertible to `Ret` +then inherits from __true_type, +otherwise inherits from __false_type. + +The default behaviour (`Ret=dont_care`) is to not check for the return value of binary `operator&=`. +If `Ret` is different from the default `dont_care` type, the return value is checked to be convertible to `Ret`. +Convertible to `Ret` means that the return value of the operator can be used as argument to a function expecting `Ret`: +`` +void f(Ret); +Lhs lhs; +Rhs rhs; +f(lhs&=rhs); // is valid if has_bit_and_assign<Lhs, Rhs, Ret>::value==true +`` +If `Ret=void`, the return type is checked to be exactly `void`. + +__header `#include <boost/type_traits/has_bit_and_assign.hpp>` or `#include <boost/type_traits/has_operator.hpp>` or `#include <boost/type_traits.hpp>` + +__examples + +[:`has_bit_and_assign<Lhs, Rhs, Ret>::value_type` is the type `bool`.] +[:`has_bit_and_assign<Lhs, Rhs, Ret>::value` is a `bool` integral constant expression.] +[:`has_bit_and_assign<int>::value` is a `bool` integral constant expression that evaluates to `true`.] +[:`has_bit_and_assign<long>` inherits from `__true_type`.] + +[:`has_bit_and_assign<int, int, int>` inherits from `__true_type`.] + +[:`has_bit_and_assign<const int, int>` inherits from `__false_type`.] +[:`has_bit_and_assign<int, double, bool>` inherits from `__false_type`.] +[:`has_bit_and_assign<int, int, std::string>` inherits from `__false_type`.] + + +[*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits] + +[*Limitation:] + +* Requires a compiler with working SFINAE. + +[*Known issues:] + +* This trait cannot detect whether binary `operator&=` is public or not: +if `operator&=` is defined as a private member of `Lhs` then +instantiating `has_bit_and_assign<Lhs>` will produce a compiler error. +For this reason `has_bit_and_assign` cannot be used to determine whether a type has a public `operator&=` or not. +`` +struct A { private: void operator&=(const A&); }; +boost::has_bit_and_assign<A>::value; // error: A::operator&=(const A&) is private +`` + +* There is an issue if the operator exists only for type `A` and `B` is +convertible to `A`. In this case, the compiler will report an ambiguous overload. +`` +struct A { }; +void operator&=(const A&, const A&); +struct B { operator A(); }; +boost::has_bit_and_assign<A>::value; // this is fine +boost::has_bit_and_assign<B>::value; // error: ambiguous overload +`` + +* There is an issue when applying this trait to template classes. +If `operator&=` is defined but does not bind for a given template type, +it is still detected by the trait which returns `true` instead of `false`. +Example: +`` +#include <boost/type_traits/has_bit_and_assign.hpp> +#include <iostream> + +template <class T> +struct contains { T data; }; + +template <class T> +bool operator&=(const contains<T> &lhs, const contains<T> &rhs) { + return f(lhs.data, rhs.data); +} + +class bad { }; +class good { }; +bool f(const good&, const good&) { } + +int main() { + std::cout<<std::boolalpha; + // works fine for contains<good> + std::cout<<boost::has_bit_and_assign< contains< good > >::value<<'\n'; // true + contains<good> g; + g&=g; // ok + // does not work for contains<bad> + std::cout<<boost::has_bit_and_assign< contains< bad > >::value<<'\n'; // true, should be false + contains<bad> b; + b&=b; // compile time error + return 0; +} +`` + +* `volatile` qualifier is not properly handled and would lead to undefined behavior + +[endsect] + diff --git a/libs/type_traits/doc/has_bit_or.qbk b/libs/type_traits/doc/has_bit_or.qbk new file mode 100644 index 0000000000..30bdaf845e --- /dev/null +++ b/libs/type_traits/doc/has_bit_or.qbk @@ -0,0 +1,109 @@ +[/ + (C) Copyright 2009-2011 Frederic Bron. + 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_bit_or has_bit_or] + template <class Lhs, class Rhs=Lhs, class Ret=dont_care> + struct has_bit_or : public __tof {}; + +__inherit +If (i) `lhs` of type `Lhs` and `rhs` of type `Rhs` can be used in expression `lhs|rhs`, +and (ii) `Ret=dont_care` or the result of expression `lhs|rhs` is convertible to `Ret` +then inherits from __true_type, +otherwise inherits from __false_type. + +The default behaviour (`Ret=dont_care`) is to not check for the return value of binary `operator|`. +If `Ret` is different from the default `dont_care` type, the return value is checked to be convertible to `Ret`. +Convertible to `Ret` means that the return value of the operator can be used as argument to a function expecting `Ret`: +`` +void f(Ret); +Lhs lhs; +Rhs rhs; +f(lhs|rhs); // is valid if has_bit_or<Lhs, Rhs, Ret>::value==true +`` +If `Ret=void`, the return type is checked to be exactly `void`. + +__header `#include <boost/type_traits/has_bit_or.hpp>` or `#include <boost/type_traits/has_operator.hpp>` or `#include <boost/type_traits.hpp>` + +__examples + +[:`has_bit_or<Lhs, Rhs, Ret>::value_type` is the type `bool`.] +[:`has_bit_or<Lhs, Rhs, Ret>::value` is a `bool` integral constant expression.] +[:`has_bit_or<int>::value` is a `bool` integral constant expression that evaluates to `true`.] +[:`has_bit_or<long>` inherits from `__true_type`.] + +[:`has_bit_or<int, int, int>` inherits from `__true_type`.] +[:`has_bit_or<const int, int>` inherits from `__true_type`.] + +[:`has_bit_or<int, double, bool>` inherits from `__false_type`.] +[:`has_bit_or<int, int, std::string>` inherits from `__false_type`.] + + +[*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits] + +[*Limitation:] + +* Requires a compiler with working SFINAE. + +[*Known issues:] + +* This trait cannot detect whether binary `operator|` is public or not: +if `operator|` is defined as a private member of `Lhs` then +instantiating `has_bit_or<Lhs>` will produce a compiler error. +For this reason `has_bit_or` cannot be used to determine whether a type has a public `operator|` or not. +`` +struct A { private: void operator|(const A&); }; +boost::has_bit_or<A>::value; // error: A::operator|(const A&) is private +`` + +* There is an issue if the operator exists only for type `A` and `B` is +convertible to `A`. In this case, the compiler will report an ambiguous overload. +`` +struct A { }; +void operator|(const A&, const A&); +struct B { operator A(); }; +boost::has_bit_or<A>::value; // this is fine +boost::has_bit_or<B>::value; // error: ambiguous overload +`` + +* There is an issue when applying this trait to template classes. +If `operator|` is defined but does not bind for a given template type, +it is still detected by the trait which returns `true` instead of `false`. +Example: +`` +#include <boost/type_traits/has_bit_or.hpp> +#include <iostream> + +template <class T> +struct contains { T data; }; + +template <class T> +bool operator|(const contains<T> &lhs, const contains<T> &rhs) { + return f(lhs.data, rhs.data); +} + +class bad { }; +class good { }; +bool f(const good&, const good&) { } + +int main() { + std::cout<<std::boolalpha; + // works fine for contains<good> + std::cout<<boost::has_bit_or< contains< good > >::value<<'\n'; // true + contains<good> g; + g|g; // ok + // does not work for contains<bad> + std::cout<<boost::has_bit_or< contains< bad > >::value<<'\n'; // true, should be false + contains<bad> b; + b|b; // compile time error + return 0; +} +`` + +* `volatile` qualifier is not properly handled and would lead to undefined behavior + +[endsect] + diff --git a/libs/type_traits/doc/has_bit_or_assign.qbk b/libs/type_traits/doc/has_bit_or_assign.qbk new file mode 100644 index 0000000000..7eb37f216f --- /dev/null +++ b/libs/type_traits/doc/has_bit_or_assign.qbk @@ -0,0 +1,109 @@ +[/ + (C) Copyright 2009-2011 Frederic Bron. + 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_bit_or_assign has_bit_or_assign] + template <class Lhs, class Rhs=Lhs, class Ret=dont_care> + struct has_bit_or_assign : public __tof {}; + +__inherit +If (i) `lhs` of type `Lhs` and `rhs` of type `Rhs` can be used in expression `lhs|=rhs`, +and (ii) `Ret=dont_care` or the result of expression `lhs|=rhs` is convertible to `Ret` +then inherits from __true_type, +otherwise inherits from __false_type. + +The default behaviour (`Ret=dont_care`) is to not check for the return value of binary `operator|=`. +If `Ret` is different from the default `dont_care` type, the return value is checked to be convertible to `Ret`. +Convertible to `Ret` means that the return value of the operator can be used as argument to a function expecting `Ret`: +`` +void f(Ret); +Lhs lhs; +Rhs rhs; +f(lhs|=rhs); // is valid if has_bit_or_assign<Lhs, Rhs, Ret>::value==true +`` +If `Ret=void`, the return type is checked to be exactly `void`. + +__header `#include <boost/type_traits/has_bit_or_assign.hpp>` or `#include <boost/type_traits/has_operator.hpp>` or `#include <boost/type_traits.hpp>` + +__examples + +[:`has_bit_or_assign<Lhs, Rhs, Ret>::value_type` is the type `bool`.] +[:`has_bit_or_assign<Lhs, Rhs, Ret>::value` is a `bool` integral constant expression.] +[:`has_bit_or_assign<int>::value` is a `bool` integral constant expression that evaluates to `true`.] +[:`has_bit_or_assign<long>` inherits from `__true_type`.] + +[:`has_bit_or_assign<int, int, int>` inherits from `__true_type`.] + +[:`has_bit_or_assign<const int, int>` inherits from `__false_type`.] +[:`has_bit_or_assign<int, double, bool>` inherits from `__false_type`.] +[:`has_bit_or_assign<int, int, std::string>` inherits from `__false_type`.] + + +[*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits] + +[*Limitation:] + +* Requires a compiler with working SFINAE. + +[*Known issues:] + +* This trait cannot detect whether binary `operator|=` is public or not: +if `operator|=` is defined as a private member of `Lhs` then +instantiating `has_bit_or_assign<Lhs>` will produce a compiler error. +For this reason `has_bit_or_assign` cannot be used to determine whether a type has a public `operator|=` or not. +`` +struct A { private: void operator|=(const A&); }; +boost::has_bit_or_assign<A>::value; // error: A::operator|=(const A&) is private +`` + +* There is an issue if the operator exists only for type `A` and `B` is +convertible to `A`. In this case, the compiler will report an ambiguous overload. +`` +struct A { }; +void operator|=(const A&, const A&); +struct B { operator A(); }; +boost::has_bit_or_assign<A>::value; // this is fine +boost::has_bit_or_assign<B>::value; // error: ambiguous overload +`` + +* There is an issue when applying this trait to template classes. +If `operator|=` is defined but does not bind for a given template type, +it is still detected by the trait which returns `true` instead of `false`. +Example: +`` +#include <boost/type_traits/has_bit_or_assign.hpp> +#include <iostream> + +template <class T> +struct contains { T data; }; + +template <class T> +bool operator|=(const contains<T> &lhs, const contains<T> &rhs) { + return f(lhs.data, rhs.data); +} + +class bad { }; +class good { }; +bool f(const good&, const good&) { } + +int main() { + std::cout<<std::boolalpha; + // works fine for contains<good> + std::cout<<boost::has_bit_or_assign< contains< good > >::value<<'\n'; // true + contains<good> g; + g|=g; // ok + // does not work for contains<bad> + std::cout<<boost::has_bit_or_assign< contains< bad > >::value<<'\n'; // true, should be false + contains<bad> b; + b|=b; // compile time error + return 0; +} +`` + +* `volatile` qualifier is not properly handled and would lead to undefined behavior + +[endsect] + diff --git a/libs/type_traits/doc/has_bit_xor.qbk b/libs/type_traits/doc/has_bit_xor.qbk new file mode 100644 index 0000000000..874cf4257b --- /dev/null +++ b/libs/type_traits/doc/has_bit_xor.qbk @@ -0,0 +1,109 @@ +[/ + (C) Copyright 2009-2011 Frederic Bron. + 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_bit_xor has_bit_xor] + template <class Lhs, class Rhs=Lhs, class Ret=dont_care> + struct has_bit_xor : public __tof {}; + +__inherit +If (i) `lhs` of type `Lhs` and `rhs` of type `Rhs` can be used in expression `lhs^rhs`, +and (ii) `Ret=dont_care` or the result of expression `lhs^rhs` is convertible to `Ret` +then inherits from __true_type, +otherwise inherits from __false_type. + +The default behaviour (`Ret=dont_care`) is to not check for the return value of binary `operator^`. +If `Ret` is different from the default `dont_care` type, the return value is checked to be convertible to `Ret`. +Convertible to `Ret` means that the return value of the operator can be used as argument to a function expecting `Ret`: +`` +void f(Ret); +Lhs lhs; +Rhs rhs; +f(lhs^rhs); // is valid if has_bit_xor<Lhs, Rhs, Ret>::value==true +`` +If `Ret=void`, the return type is checked to be exactly `void`. + +__header `#include <boost/type_traits/has_bit_xor.hpp>` or `#include <boost/type_traits/has_operator.hpp>` or `#include <boost/type_traits.hpp>` + +__examples + +[:`has_bit_xor<Lhs, Rhs, Ret>::value_type` is the type `bool`.] +[:`has_bit_xor<Lhs, Rhs, Ret>::value` is a `bool` integral constant expression.] +[:`has_bit_xor<int>::value` is a `bool` integral constant expression that evaluates to `true`.] +[:`has_bit_xor<long>` inherits from `__true_type`.] + +[:`has_bit_xor<int, int, int>` inherits from `__true_type`.] +[:`has_bit_xor<const int, int>` inherits from `__true_type`.] + +[:`has_bit_xor<int, double, bool>` inherits from `__false_type`.] +[:`has_bit_xor<int, int, std::string>` inherits from `__false_type`.] + + +[*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits] + +[*Limitation:] + +* Requires a compiler with working SFINAE. + +[*Known issues:] + +* This trait cannot detect whether binary `operator^` is public or not: +if `operator^` is defined as a private member of `Lhs` then +instantiating `has_bit_xor<Lhs>` will produce a compiler error. +For this reason `has_bit_xor` cannot be used to determine whether a type has a public `operator^` or not. +`` +struct A { private: void operator^(const A&); }; +boost::has_bit_xor<A>::value; // error: A::operator^(const A&) is private +`` + +* There is an issue if the operator exists only for type `A` and `B` is +convertible to `A`. In this case, the compiler will report an ambiguous overload. +`` +struct A { }; +void operator^(const A&, const A&); +struct B { operator A(); }; +boost::has_bit_xor<A>::value; // this is fine +boost::has_bit_xor<B>::value; // error: ambiguous overload +`` + +* There is an issue when applying this trait to template classes. +If `operator^` is defined but does not bind for a given template type, +it is still detected by the trait which returns `true` instead of `false`. +Example: +`` +#include <boost/type_traits/has_bit_xor.hpp> +#include <iostream> + +template <class T> +struct contains { T data; }; + +template <class T> +bool operator^(const contains<T> &lhs, const contains<T> &rhs) { + return f(lhs.data, rhs.data); +} + +class bad { }; +class good { }; +bool f(const good&, const good&) { } + +int main() { + std::cout<<std::boolalpha; + // works fine for contains<good> + std::cout<<boost::has_bit_xor< contains< good > >::value<<'\n'; // true + contains<good> g; + g^g; // ok + // does not work for contains<bad> + std::cout<<boost::has_bit_xor< contains< bad > >::value<<'\n'; // true, should be false + contains<bad> b; + b^b; // compile time error + return 0; +} +`` + +* `volatile` qualifier is not properly handled and would lead to undefined behavior + +[endsect] + diff --git a/libs/type_traits/doc/has_bit_xor_assign.qbk b/libs/type_traits/doc/has_bit_xor_assign.qbk new file mode 100644 index 0000000000..4e503ba571 --- /dev/null +++ b/libs/type_traits/doc/has_bit_xor_assign.qbk @@ -0,0 +1,109 @@ +[/ + (C) Copyright 2009-2011 Frederic Bron. + 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_bit_xor_assign has_bit_xor_assign] + template <class Lhs, class Rhs=Lhs, class Ret=dont_care> + struct has_bit_xor_assign : public __tof {}; + +__inherit +If (i) `lhs` of type `Lhs` and `rhs` of type `Rhs` can be used in expression `lhs^=rhs`, +and (ii) `Ret=dont_care` or the result of expression `lhs^=rhs` is convertible to `Ret` +then inherits from __true_type, +otherwise inherits from __false_type. + +The default behaviour (`Ret=dont_care`) is to not check for the return value of binary `operator^=`. +If `Ret` is different from the default `dont_care` type, the return value is checked to be convertible to `Ret`. +Convertible to `Ret` means that the return value of the operator can be used as argument to a function expecting `Ret`: +`` +void f(Ret); +Lhs lhs; +Rhs rhs; +f(lhs^=rhs); // is valid if has_bit_xor_assign<Lhs, Rhs, Ret>::value==true +`` +If `Ret=void`, the return type is checked to be exactly `void`. + +__header `#include <boost/type_traits/has_bit_xor_assign.hpp>` or `#include <boost/type_traits/has_operator.hpp>` or `#include <boost/type_traits.hpp>` + +__examples + +[:`has_bit_xor_assign<Lhs, Rhs, Ret>::value_type` is the type `bool`.] +[:`has_bit_xor_assign<Lhs, Rhs, Ret>::value` is a `bool` integral constant expression.] +[:`has_bit_xor_assign<int>::value` is a `bool` integral constant expression that evaluates to `true`.] +[:`has_bit_xor_assign<long>` inherits from `__true_type`.] + +[:`has_bit_xor_assign<int, int, int>` inherits from `__true_type`.] + +[:`has_bit_xor_assign<const int, int>` inherits from `__false_type`.] +[:`has_bit_xor_assign<int, double, bool>` inherits from `__false_type`.] +[:`has_bit_xor_assign<int, int, std::string>` inherits from `__false_type`.] + + +[*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits] + +[*Limitation:] + +* Requires a compiler with working SFINAE. + +[*Known issues:] + +* This trait cannot detect whether binary `operator^=` is public or not: +if `operator^=` is defined as a private member of `Lhs` then +instantiating `has_bit_xor_assign<Lhs>` will produce a compiler error. +For this reason `has_bit_xor_assign` cannot be used to determine whether a type has a public `operator^=` or not. +`` +struct A { private: void operator^=(const A&); }; +boost::has_bit_xor_assign<A>::value; // error: A::operator^=(const A&) is private +`` + +* There is an issue if the operator exists only for type `A` and `B` is +convertible to `A`. In this case, the compiler will report an ambiguous overload. +`` +struct A { }; +void operator^=(const A&, const A&); +struct B { operator A(); }; +boost::has_bit_xor_assign<A>::value; // this is fine +boost::has_bit_xor_assign<B>::value; // error: ambiguous overload +`` + +* There is an issue when applying this trait to template classes. +If `operator^=` is defined but does not bind for a given template type, +it is still detected by the trait which returns `true` instead of `false`. +Example: +`` +#include <boost/type_traits/has_bit_xor_assign.hpp> +#include <iostream> + +template <class T> +struct contains { T data; }; + +template <class T> +bool operator^=(const contains<T> &lhs, const contains<T> &rhs) { + return f(lhs.data, rhs.data); +} + +class bad { }; +class good { }; +bool f(const good&, const good&) { } + +int main() { + std::cout<<std::boolalpha; + // works fine for contains<good> + std::cout<<boost::has_bit_xor_assign< contains< good > >::value<<'\n'; // true + contains<good> g; + g^=g; // ok + // does not work for contains<bad> + std::cout<<boost::has_bit_xor_assign< contains< bad > >::value<<'\n'; // true, should be false + contains<bad> b; + b^=b; // compile time error + return 0; +} +`` + +* `volatile` qualifier is not properly handled and would lead to undefined behavior + +[endsect] + diff --git a/libs/type_traits/doc/has_complement.qbk b/libs/type_traits/doc/has_complement.qbk new file mode 100644 index 0000000000..c02760b0ac --- /dev/null +++ b/libs/type_traits/doc/has_complement.qbk @@ -0,0 +1,111 @@ +[/ + (C) Copyright 2009-2011 Frederic Bron. + 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_complement has_complement] + template <class Rhs, class Ret=dont_care> + struct has_complement : public __tof {}; + +__inherit +If (i) `rhs` of type `Rhs` can be used in expression `~rhs`, +and (ii) `Ret=dont_care` or the result of expression `~rhs` is convertible to `Ret` +then inherits from __true_type, +otherwise inherits from __false_type. + +The default behaviour (`Ret=dont_care`) is to not check for the return value of prefix `operator~`. +If `Ret` is different from the default `dont_care` type, the return value is checked to be convertible to `Ret`. +Convertible to `Ret` means that the return value of the operator can be used as argument to a function expecting `Ret`: +`` +void f(Ret); +Rhs rhs; +f(~rhs); // is valid if has_complement<Rhs, Ret>::value==true +`` +If `Ret=void`, the return type is checked to be exactly `void`. + +__header `#include <boost/type_traits/has_complement.hpp>` or `#include <boost/type_traits/has_operator.hpp>` or `#include <boost/type_traits.hpp>` + +__examples + +[:`has_complement<Rhs, Ret>::value_type` is the type `bool`.] +[:`has_complement<Rhs, Ret>::value` is a `bool` integral constant expression.] +[:`has_complement<int>::value` is a `bool` integral constant expression that evaluates to `true`.] +[:`has_complement<long>` inherits from `__true_type`.] + +[:`has_complement<int, int>` inherits from `__true_type`.] +[:`has_complement<int, long>` inherits from `__true_type`.] +[:`has_complement<const int>` inherits from `__true_type`.] + +[:`has_complement<int*>` inherits from `__false_type`.] +[:`has_complement<double, double>` inherits from `__false_type`.] +[:`has_complement<double, int>` inherits from `__false_type`.] +[:`has_complement<int, std::string>` inherits from `__false_type`.] + + +[*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits] + +[*Limitation:] + +* Requires a compiler with working SFINAE. + +[*Known issues:] + +* This trait cannot detect whether prefix `operator~` is public or not: +if `operator~` is defined as a private member of `Rhs` then +instantiating `has_complement<Rhs>` will produce a compiler error. +For this reason `has_complement` cannot be used to determine whether a type has a public `operator~` or not. +`` +struct A { private: void operator~(); }; +boost::has_complement<A>::value; // error: A::operator~() is private +`` + +* There is an issue if the operator exists only for type `A` and `B` is +convertible to `A`. In this case, the compiler will report an ambiguous overload. +`` +struct A { }; +void operator~(const A&); +struct B { operator A(); }; +boost::has_complement<A>::value; // this is fine +boost::has_complement<B>::value; // error: ambiguous overload +`` + +* There is an issue when applying this trait to template classes. +If `operator~` is defined but does not bind for a given template type, +it is still detected by the trait which returns `true` instead of `false`. +Example: +`` +#include <boost/type_traits/has_complement.hpp> +#include <iostream> + +template <class T> +struct contains { T data; }; + +template <class T> +bool operator~(const contains<T> &rhs) { + return f(rhs.data); +} + +class bad { }; +class good { }; +bool f(const good&) { } + +int main() { + std::cout<<std::boolalpha; + // works fine for contains<good> + std::cout<<boost::has_complement< contains< good > >::value<<'\n'; // true + contains<good> g; + ~g; // ok + // does not work for contains<bad> + std::cout<<boost::has_complement< contains< bad > >::value<<'\n'; // true, should be false + contains<bad> b; + ~b; // compile time error + return 0; +} +`` + +* `volatile` qualifier is not properly handled and would lead to undefined behavior + +[endsect] + diff --git a/libs/type_traits/doc/has_dereference.qbk b/libs/type_traits/doc/has_dereference.qbk new file mode 100644 index 0000000000..5e729da257 --- /dev/null +++ b/libs/type_traits/doc/has_dereference.qbk @@ -0,0 +1,114 @@ +[/ + (C) Copyright 2009-2011 Frederic Bron. + 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_dereference has_dereference] + template <class Rhs, class Ret=dont_care> + struct has_dereference : public __tof {}; + +__inherit +If (i) `rhs` of type `Rhs` can be used in expression `*rhs`, +and (ii) `Ret=dont_care` or the result of expression `*rhs` is convertible to `Ret` +then inherits from __true_type, +otherwise inherits from __false_type. + +The default behaviour (`Ret=dont_care`) is to not check for the return value of prefix `operator*`. +If `Ret` is different from the default `dont_care` type, the return value is checked to be convertible to `Ret`. +Convertible to `Ret` means that the return value of the operator can be used as argument to a function expecting `Ret`: +`` +void f(Ret); +Rhs rhs; +f(*rhs); // is valid if has_dereference<Rhs, Ret>::value==true +`` +If `Ret=void`, the return type is checked to be exactly `void`. + +__header `#include <boost/type_traits/has_dereference.hpp>` or `#include <boost/type_traits/has_operator.hpp>` or `#include <boost/type_traits.hpp>` + +__examples + +[:`has_dereference<Rhs, Ret>::value_type` is the type `bool`.] +[:`has_dereference<Rhs, Ret>::value` is a `bool` integral constant expression.] +[:`has_dereference<int*>::value` is a `bool` integral constant expression that evaluates to `true`.] +[:`has_dereference<long*>` inherits from `__true_type`.] + + +[:`has_dereference<int*, int>` inherits from `__true_type`.] +[:`has_dereference<int*, const int>` inherits from `__true_type`.] +[:`has_dereference<int const *>` inherits from `__true_type`.] +[:`has_dereference<int * const>` inherits from `__true_type`.] +[:`has_dereference<int const * const>` inherits from `__true_type`.] + +[:`has_dereference<int>` inherits from `__false_type`.] +[:`has_dereference<double>` inherits from `__false_type`.] +[:`has_dereference<void*>` inherits from `__false_type`.] +[:`has_dereference<const int*, int&>` inherits from `__false_type`.] + + +[*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits] + +[*Limitation:] + +* Requires a compiler with working SFINAE. + +[*Known issues:] + +* This trait cannot detect whether prefix `operator*` is public or not: +if `operator*` is defined as a private member of `Rhs` then +instantiating `has_dereference<Rhs>` will produce a compiler error. +For this reason `has_dereference` cannot be used to determine whether a type has a public `operator*` or not. +`` +struct A { private: void operator*(); }; +boost::has_dereference<A>::value; // error: A::operator*() is private +`` + +* There is an issue if the operator exists only for type `A` and `B` is +convertible to `A`. In this case, the compiler will report an ambiguous overload. +`` +struct A { }; +void operator*(const A&); +struct B { operator A(); }; +boost::has_dereference<A>::value; // this is fine +boost::has_dereference<B>::value; // error: ambiguous overload +`` + +* There is an issue when applying this trait to template classes. +If `operator*` is defined but does not bind for a given template type, +it is still detected by the trait which returns `true` instead of `false`. +Example: +`` +#include <boost/type_traits/has_dereference.hpp> +#include <iostream> + +template <class T> +struct contains { T data; }; + +template <class T> +bool operator*(const contains<T> &rhs) { + return f(rhs.data); +} + +class bad { }; +class good { }; +bool f(const good&) { } + +int main() { + std::cout<<std::boolalpha; + // works fine for contains<good> + std::cout<<boost::has_dereference< contains< good > >::value<<'\n'; // true + contains<good> g; + *g; // ok + // does not work for contains<bad> + std::cout<<boost::has_dereference< contains< bad > >::value<<'\n'; // true, should be false + contains<bad> b; + *b; // compile time error + return 0; +} +`` + +* `volatile` qualifier is not properly handled and would lead to undefined behavior + +[endsect] + diff --git a/libs/type_traits/doc/has_divides.qbk b/libs/type_traits/doc/has_divides.qbk new file mode 100644 index 0000000000..8c614b0fce --- /dev/null +++ b/libs/type_traits/doc/has_divides.qbk @@ -0,0 +1,111 @@ +[/ + (C) Copyright 2009-2011 Frederic Bron. + 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_divides has_divides] + template <class Lhs, class Rhs=Lhs, class Ret=dont_care> + struct has_divides : public __tof {}; + +__inherit +If (i) `lhs` of type `Lhs` and `rhs` of type `Rhs` can be used in expression `lhs/rhs`, +and (ii) `Ret=dont_care` or the result of expression `lhs/rhs` is convertible to `Ret` +then inherits from __true_type, +otherwise inherits from __false_type. + +The default behaviour (`Ret=dont_care`) is to not check for the return value of binary `operator/`. +If `Ret` is different from the default `dont_care` type, the return value is checked to be convertible to `Ret`. +Convertible to `Ret` means that the return value of the operator can be used as argument to a function expecting `Ret`: +`` +void f(Ret); +Lhs lhs; +Rhs rhs; +f(lhs/rhs); // is valid if has_divides<Lhs, Rhs, Ret>::value==true +`` +If `Ret=void`, the return type is checked to be exactly `void`. + +__header `#include <boost/type_traits/has_divides.hpp>` or `#include <boost/type_traits/has_operator.hpp>` or `#include <boost/type_traits.hpp>` + +__examples + +[:`has_divides<Lhs, Rhs, Ret>::value_type` is the type `bool`.] +[:`has_divides<Lhs, Rhs, Ret>::value` is a `bool` integral constant expression.] +[:`has_divides<int>::value` is a `bool` integral constant expression that evaluates to `true`.] +[:`has_divides<long>` inherits from `__true_type`.] + +[:`has_divides<int, int, int>` inherits from `__true_type`.] +[:`has_divides<int, int, long>` inherits from `__true_type`.] +[:`has_divides<int, double, double>` inherits from `__true_type`.] +[:`has_divides<int, double, int>` inherits from `__true_type`.] +[:`has_divides<const int, int>::value` inherits from `__true_type`.] + +[:`has_divides<int, int, std::string>` inherits from `__false_type`.] + + +[*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits] + +[*Limitation:] + +* Requires a compiler with working SFINAE. + +[*Known issues:] + +* This trait cannot detect whether binary `operator/` is public or not: +if `operator/` is defined as a private member of `Lhs` then +instantiating `has_divides<Lhs>` will produce a compiler error. +For this reason `has_divides` cannot be used to determine whether a type has a public `operator/` or not. +`` +struct A { private: void operator/(const A&); }; +boost::has_divides<A>::value; // error: A::operator/(const A&) is private +`` + +* There is an issue if the operator exists only for type `A` and `B` is +convertible to `A`. In this case, the compiler will report an ambiguous overload. +`` +struct A { }; +void operator/(const A&, const A&); +struct B { operator A(); }; +boost::has_divides<A>::value; // this is fine +boost::has_divides<B>::value; // error: ambiguous overload +`` + +* There is an issue when applying this trait to template classes. +If `operator/` is defined but does not bind for a given template type, +it is still detected by the trait which returns `true` instead of `false`. +Example: +`` +#include <boost/type_traits/has_divides.hpp> +#include <iostream> + +template <class T> +struct contains { T data; }; + +template <class T> +bool operator/(const contains<T> &lhs, const contains<T> &rhs) { + return f(lhs.data, rhs.data); +} + +class bad { }; +class good { }; +bool f(const good&, const good&) { } + +int main() { + std::cout<<std::boolalpha; + // works fine for contains<good> + std::cout<<boost::has_divides< contains< good > >::value<<'\n'; // true + contains<good> g; + g/g; // ok + // does not work for contains<bad> + std::cout<<boost::has_divides< contains< bad > >::value<<'\n'; // true, should be false + contains<bad> b; + b/b; // compile time error + return 0; +} +`` + +* `volatile` qualifier is not properly handled and would lead to undefined behavior + +[endsect] + diff --git a/libs/type_traits/doc/has_divides_assign.qbk b/libs/type_traits/doc/has_divides_assign.qbk new file mode 100644 index 0000000000..393da4115b --- /dev/null +++ b/libs/type_traits/doc/has_divides_assign.qbk @@ -0,0 +1,111 @@ +[/ + (C) Copyright 2009-2011 Frederic Bron. + 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_divides_assign has_divides_assign] + template <class Lhs, class Rhs=Lhs, class Ret=dont_care> + struct has_divides_assign : public __tof {}; + +__inherit +If (i) `lhs` of type `Lhs` and `rhs` of type `Rhs` can be used in expression `lhs/=rhs`, +and (ii) `Ret=dont_care` or the result of expression `lhs/=rhs` is convertible to `Ret` +then inherits from __true_type, +otherwise inherits from __false_type. + +The default behaviour (`Ret=dont_care`) is to not check for the return value of binary `operator/=`. +If `Ret` is different from the default `dont_care` type, the return value is checked to be convertible to `Ret`. +Convertible to `Ret` means that the return value of the operator can be used as argument to a function expecting `Ret`: +`` +void f(Ret); +Lhs lhs; +Rhs rhs; +f(lhs/=rhs); // is valid if has_divides_assign<Lhs, Rhs, Ret>::value==true +`` +If `Ret=void`, the return type is checked to be exactly `void`. + +__header `#include <boost/type_traits/has_divides_assign.hpp>` or `#include <boost/type_traits/has_operator.hpp>` or `#include <boost/type_traits.hpp>` + +__examples + +[:`has_divides_assign<Lhs, Rhs, Ret>::value_type` is the type `bool`.] +[:`has_divides_assign<Lhs, Rhs, Ret>::value` is a `bool` integral constant expression.] +[:`has_divides_assign<int>::value` is a `bool` integral constant expression that evaluates to `true`.] +[:`has_divides_assign<long>` inherits from `__true_type`.] + +[:`has_divides_assign<int, int, int>` inherits from `__true_type`.] +[:`has_divides_assign<int, int, long>` inherits from `__true_type`.] +[:`has_divides_assign<int, double, double>` inherits from `__true_type`.] +[:`has_divides_assign<int, double, int>` inherits from `__true_type`.] + +[:`has_divides_assign<const int, int>::value` inherits from `__false_type`.] +[:`has_divides_assign<int, int, std::string>` inherits from `__false_type`.] + + +[*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits] + +[*Limitation:] + +* Requires a compiler with working SFINAE. + +[*Known issues:] + +* This trait cannot detect whether binary `operator/=` is public or not: +if `operator/=` is defined as a private member of `Lhs` then +instantiating `has_divides_assign<Lhs>` will produce a compiler error. +For this reason `has_divides_assign` cannot be used to determine whether a type has a public `operator/=` or not. +`` +struct A { private: void operator/=(const A&); }; +boost::has_divides_assign<A>::value; // error: A::operator/=(const A&) is private +`` + +* There is an issue if the operator exists only for type `A` and `B` is +convertible to `A`. In this case, the compiler will report an ambiguous overload. +`` +struct A { }; +void operator/=(const A&, const A&); +struct B { operator A(); }; +boost::has_divides_assign<A>::value; // this is fine +boost::has_divides_assign<B>::value; // error: ambiguous overload +`` + +* There is an issue when applying this trait to template classes. +If `operator/=` is defined but does not bind for a given template type, +it is still detected by the trait which returns `true` instead of `false`. +Example: +`` +#include <boost/type_traits/has_divides_assign.hpp> +#include <iostream> + +template <class T> +struct contains { T data; }; + +template <class T> +bool operator/=(const contains<T> &lhs, const contains<T> &rhs) { + return f(lhs.data, rhs.data); +} + +class bad { }; +class good { }; +bool f(const good&, const good&) { } + +int main() { + std::cout<<std::boolalpha; + // works fine for contains<good> + std::cout<<boost::has_divides_assign< contains< good > >::value<<'\n'; // true + contains<good> g; + g/=g; // ok + // does not work for contains<bad> + std::cout<<boost::has_divides_assign< contains< bad > >::value<<'\n'; // true, should be false + contains<bad> b; + b/=b; // compile time error + return 0; +} +`` + +* `volatile` qualifier is not properly handled and would lead to undefined behavior + +[endsect] + diff --git a/libs/type_traits/doc/has_equal_to.qbk b/libs/type_traits/doc/has_equal_to.qbk new file mode 100644 index 0000000000..78203d347c --- /dev/null +++ b/libs/type_traits/doc/has_equal_to.qbk @@ -0,0 +1,111 @@ +[/ + (C) Copyright 2009-2011 Frederic Bron. + 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_equal_to has_equal_to] + template <class Lhs, class Rhs=Lhs, class Ret=dont_care> + struct has_equal_to : public __tof {}; + +__inherit +If (i) `lhs` of type `Lhs` and `rhs` of type `Rhs` can be used in expression `lhs==rhs`, +and (ii) `Ret=dont_care` or the result of expression `lhs==rhs` is convertible to `Ret` +then inherits from __true_type, +otherwise inherits from __false_type. + +The default behaviour (`Ret=dont_care`) is to not check for the return value of binary `operator==`. +If `Ret` is different from the default `dont_care` type, the return value is checked to be convertible to `Ret`. +Convertible to `Ret` means that the return value of the operator can be used as argument to a function expecting `Ret`: +`` +void f(Ret); +Lhs lhs; +Rhs rhs; +f(lhs==rhs); // is valid if has_equal_to<Lhs, Rhs, Ret>::value==true +`` +If `Ret=void`, the return type is checked to be exactly `void`. + +__header `#include <boost/type_traits/has_equal_to.hpp>` or `#include <boost/type_traits/has_operator.hpp>` or `#include <boost/type_traits.hpp>` + +__examples + +[:`has_equal_to<Lhs, Rhs, Ret>::value_type` is the type `bool`.] +[:`has_equal_to<Lhs, Rhs, Ret>::value` is a `bool` integral constant expression.] +[:`has_equal_to<int>::value` is a `bool` integral constant expression that evaluates to `true`.] +[:`has_equal_to<long>` inherits from `__true_type`.] + +[:`has_equal_to<int, int, bool>` inherits from `__true_type`.] +[:`has_equal_to<int, double, bool>` inherits from `__true_type`.] +[:`has_equal_to<const int>` inherits from `__true_type`.] + +[:`has_equal_to<int*, int>` inherits from `__false_type`.] +[:`has_equal_to<int*, double*>` inherits from `__false_type`.] +[:`has_equal_to<int, int, std::string>` inherits from `__false_type`.] + + +[*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits] + +[*Limitation:] + +* Requires a compiler with working SFINAE. + +[*Known issues:] + +* This trait cannot detect whether binary `operator==` is public or not: +if `operator==` is defined as a private member of `Lhs` then +instantiating `has_equal_to<Lhs>` will produce a compiler error. +For this reason `has_equal_to` cannot be used to determine whether a type has a public `operator==` or not. +`` +struct A { private: void operator==(const A&); }; +boost::has_equal_to<A>::value; // error: A::operator==(const A&) is private +`` + +* There is an issue if the operator exists only for type `A` and `B` is +convertible to `A`. In this case, the compiler will report an ambiguous overload. +`` +struct A { }; +void operator==(const A&, const A&); +struct B { operator A(); }; +boost::has_equal_to<A>::value; // this is fine +boost::has_equal_to<B>::value; // error: ambiguous overload +`` + +* There is an issue when applying this trait to template classes. +If `operator==` is defined but does not bind for a given template type, +it is still detected by the trait which returns `true` instead of `false`. +Example: +`` +#include <boost/type_traits/has_equal_to.hpp> +#include <iostream> + +template <class T> +struct contains { T data; }; + +template <class T> +bool operator==(const contains<T> &lhs, const contains<T> &rhs) { + return f(lhs.data, rhs.data); +} + +class bad { }; +class good { }; +bool f(const good&, const good&) { } + +int main() { + std::cout<<std::boolalpha; + // works fine for contains<good> + std::cout<<boost::has_equal_to< contains< good > >::value<<'\n'; // true + contains<good> g; + g==g; // ok + // does not work for contains<bad> + std::cout<<boost::has_equal_to< contains< bad > >::value<<'\n'; // true, should be false + contains<bad> b; + b==b; // compile time error + return 0; +} +`` + +* `volatile` qualifier is not properly handled and would lead to undefined behavior + +[endsect] + diff --git a/libs/type_traits/doc/has_greater.qbk b/libs/type_traits/doc/has_greater.qbk new file mode 100644 index 0000000000..b9be45fee4 --- /dev/null +++ b/libs/type_traits/doc/has_greater.qbk @@ -0,0 +1,111 @@ +[/ + (C) Copyright 2009-2011 Frederic Bron. + 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_greater has_greater] + template <class Lhs, class Rhs=Lhs, class Ret=dont_care> + struct has_greater : public __tof {}; + +__inherit +If (i) `lhs` of type `Lhs` and `rhs` of type `Rhs` can be used in expression `lhs>rhs`, +and (ii) `Ret=dont_care` or the result of expression `lhs>rhs` is convertible to `Ret` +then inherits from __true_type, +otherwise inherits from __false_type. + +The default behaviour (`Ret=dont_care`) is to not check for the return value of binary `operator>`. +If `Ret` is different from the default `dont_care` type, the return value is checked to be convertible to `Ret`. +Convertible to `Ret` means that the return value of the operator can be used as argument to a function expecting `Ret`: +`` +void f(Ret); +Lhs lhs; +Rhs rhs; +f(lhs>rhs); // is valid if has_greater<Lhs, Rhs, Ret>::value==true +`` +If `Ret=void`, the return type is checked to be exactly `void`. + +__header `#include <boost/type_traits/has_greater.hpp>` or `#include <boost/type_traits/has_operator.hpp>` or `#include <boost/type_traits.hpp>` + +__examples + +[:`has_greater<Lhs, Rhs, Ret>::value_type` is the type `bool`.] +[:`has_greater<Lhs, Rhs, Ret>::value` is a `bool` integral constant expression.] +[:`has_greater<int>::value` is a `bool` integral constant expression that evaluates to `true`.] +[:`has_greater<long>` inherits from `__true_type`.] + +[:`has_greater<int, int, bool>` inherits from `__true_type`.] +[:`has_greater<int, double, bool>` inherits from `__true_type`.] +[:`has_greater<const int>` inherits from `__true_type`.] + +[:`has_greater<int*, int>` inherits from `__false_type`.] +[:`has_greater<int*, double*>` inherits from `__false_type`.] +[:`has_greater<int, int, std::string>` inherits from `__false_type`.] + + +[*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits] + +[*Limitation:] + +* Requires a compiler with working SFINAE. + +[*Known issues:] + +* This trait cannot detect whether binary `operator>` is public or not: +if `operator>` is defined as a private member of `Lhs` then +instantiating `has_greater<Lhs>` will produce a compiler error. +For this reason `has_greater` cannot be used to determine whether a type has a public `operator>` or not. +`` +struct A { private: void operator>(const A&); }; +boost::has_greater<A>::value; // error: A::operator>(const A&) is private +`` + +* There is an issue if the operator exists only for type `A` and `B` is +convertible to `A`. In this case, the compiler will report an ambiguous overload. +`` +struct A { }; +void operator>(const A&, const A&); +struct B { operator A(); }; +boost::has_greater<A>::value; // this is fine +boost::has_greater<B>::value; // error: ambiguous overload +`` + +* There is an issue when applying this trait to template classes. +If `operator>` is defined but does not bind for a given template type, +it is still detected by the trait which returns `true` instead of `false`. +Example: +`` +#include <boost/type_traits/has_greater.hpp> +#include <iostream> + +template <class T> +struct contains { T data; }; + +template <class T> +bool operator>(const contains<T> &lhs, const contains<T> &rhs) { + return f(lhs.data, rhs.data); +} + +class bad { }; +class good { }; +bool f(const good&, const good&) { } + +int main() { + std::cout<<std::boolalpha; + // works fine for contains<good> + std::cout<<boost::has_greater< contains< good > >::value<<'\n'; // true + contains<good> g; + g>g; // ok + // does not work for contains<bad> + std::cout<<boost::has_greater< contains< bad > >::value<<'\n'; // true, should be false + contains<bad> b; + b>b; // compile time error + return 0; +} +`` + +* `volatile` qualifier is not properly handled and would lead to undefined behavior + +[endsect] + diff --git a/libs/type_traits/doc/has_greater_equal.qbk b/libs/type_traits/doc/has_greater_equal.qbk new file mode 100644 index 0000000000..9ea1caeea7 --- /dev/null +++ b/libs/type_traits/doc/has_greater_equal.qbk @@ -0,0 +1,111 @@ +[/ + (C) Copyright 2009-2011 Frederic Bron. + 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_greater_equal has_greater_equal] + template <class Lhs, class Rhs=Lhs, class Ret=dont_care> + struct has_greater_equal : public __tof {}; + +__inherit +If (i) `lhs` of type `Lhs` and `rhs` of type `Rhs` can be used in expression `lhs>=rhs`, +and (ii) `Ret=dont_care` or the result of expression `lhs>=rhs` is convertible to `Ret` +then inherits from __true_type, +otherwise inherits from __false_type. + +The default behaviour (`Ret=dont_care`) is to not check for the return value of binary `operator>=`. +If `Ret` is different from the default `dont_care` type, the return value is checked to be convertible to `Ret`. +Convertible to `Ret` means that the return value of the operator can be used as argument to a function expecting `Ret`: +`` +void f(Ret); +Lhs lhs; +Rhs rhs; +f(lhs>=rhs); // is valid if has_greater_equal<Lhs, Rhs, Ret>::value==true +`` +If `Ret=void`, the return type is checked to be exactly `void`. + +__header `#include <boost/type_traits/has_greater_equal.hpp>` or `#include <boost/type_traits/has_operator.hpp>` or `#include <boost/type_traits.hpp>` + +__examples + +[:`has_greater_equal<Lhs, Rhs, Ret>::value_type` is the type `bool`.] +[:`has_greater_equal<Lhs, Rhs, Ret>::value` is a `bool` integral constant expression.] +[:`has_greater_equal<int>::value` is a `bool` integral constant expression that evaluates to `true`.] +[:`has_greater_equal<long>` inherits from `__true_type`.] + +[:`has_greater_equal<int, int, bool>` inherits from `__true_type`.] +[:`has_greater_equal<int, double, bool>` inherits from `__true_type`.] +[:`has_greater_equal<const int>` inherits from `__true_type`.] + +[:`has_greater_equal<int*, int>` inherits from `__false_type`.] +[:`has_greater_equal<int*, double*>` inherits from `__false_type`.] +[:`has_greater_equal<int, int, std::string>` inherits from `__false_type`.] + + +[*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits] + +[*Limitation:] + +* Requires a compiler with working SFINAE. + +[*Known issues:] + +* This trait cannot detect whether binary `operator>=` is public or not: +if `operator>=` is defined as a private member of `Lhs` then +instantiating `has_greater_equal<Lhs>` will produce a compiler error. +For this reason `has_greater_equal` cannot be used to determine whether a type has a public `operator>=` or not. +`` +struct A { private: void operator>=(const A&); }; +boost::has_greater_equal<A>::value; // error: A::operator>=(const A&) is private +`` + +* There is an issue if the operator exists only for type `A` and `B` is +convertible to `A`. In this case, the compiler will report an ambiguous overload. +`` +struct A { }; +void operator>=(const A&, const A&); +struct B { operator A(); }; +boost::has_greater_equal<A>::value; // this is fine +boost::has_greater_equal<B>::value; // error: ambiguous overload +`` + +* There is an issue when applying this trait to template classes. +If `operator>=` is defined but does not bind for a given template type, +it is still detected by the trait which returns `true` instead of `false`. +Example: +`` +#include <boost/type_traits/has_greater_equal.hpp> +#include <iostream> + +template <class T> +struct contains { T data; }; + +template <class T> +bool operator>=(const contains<T> &lhs, const contains<T> &rhs) { + return f(lhs.data, rhs.data); +} + +class bad { }; +class good { }; +bool f(const good&, const good&) { } + +int main() { + std::cout<<std::boolalpha; + // works fine for contains<good> + std::cout<<boost::has_greater_equal< contains< good > >::value<<'\n'; // true + contains<good> g; + g>=g; // ok + // does not work for contains<bad> + std::cout<<boost::has_greater_equal< contains< bad > >::value<<'\n'; // true, should be false + contains<bad> b; + b>=b; // compile time error + return 0; +} +`` + +* `volatile` qualifier is not properly handled and would lead to undefined behavior + +[endsect] + diff --git a/libs/type_traits/doc/has_left_shift.qbk b/libs/type_traits/doc/has_left_shift.qbk new file mode 100644 index 0000000000..fa43945624 --- /dev/null +++ b/libs/type_traits/doc/has_left_shift.qbk @@ -0,0 +1,112 @@ +[/ + (C) Copyright 2009-2011 Frederic Bron. + 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_left_shift has_left_shift] + template <class Lhs, class Rhs=Lhs, class Ret=dont_care> + struct has_left_shift : public __tof {}; + +__inherit +If (i) `lhs` of type `Lhs` and `rhs` of type `Rhs` can be used in expression `lhs<<rhs`, +and (ii) `Ret=dont_care` or the result of expression `lhs<<rhs` is convertible to `Ret` +then inherits from __true_type, +otherwise inherits from __false_type. + +The default behaviour (`Ret=dont_care`) is to not check for the return value of binary `operator<<`. +If `Ret` is different from the default `dont_care` type, the return value is checked to be convertible to `Ret`. +Convertible to `Ret` means that the return value of the operator can be used as argument to a function expecting `Ret`: +`` +void f(Ret); +Lhs lhs; +Rhs rhs; +f(lhs<<rhs); // is valid if has_left_shift<Lhs, Rhs, Ret>::value==true +`` +If `Ret=void`, the return type is checked to be exactly `void`. + +__header `#include <boost/type_traits/has_left_shift.hpp>` or `#include <boost/type_traits/has_operator.hpp>` or `#include <boost/type_traits.hpp>` + +__examples + +[:`has_left_shift<Lhs, Rhs, Ret>::value_type` is the type `bool`.] +[:`has_left_shift<Lhs, Rhs, Ret>::value` is a `bool` integral constant expression.] +[:`has_left_shift<int>::value` is a `bool` integral constant expression that evaluates to `true`.] +[:`has_left_shift<long>` inherits from `__true_type`.] + +[:`has_left_shift<int, int, int>` inherits from `__true_type`.] +[:`has_left_shift<const int, int>` inherits from `__true_type`.] +[:`has_left_shift<std::ostream, int>` inherits from `__true_type`.] +[:`has_left_shift<std::ostream, char*, std::ostream>` inherits from `__true_type`.] +[:`has_left_shift<std::ostream, std::string>` inherits from `__true_type`.] + +[:`has_left_shift<int, double, bool>` inherits from `__false_type`.] +[:`has_left_shift<int, int, std::string>` inherits from `__false_type`.] + + +[*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits] + +[*Limitation:] + +* Requires a compiler with working SFINAE. + +[*Known issues:] + +* This trait cannot detect whether binary `operator<<` is public or not: +if `operator<<` is defined as a private member of `Lhs` then +instantiating `has_left_shift<Lhs>` will produce a compiler error. +For this reason `has_left_shift` cannot be used to determine whether a type has a public `operator<<` or not. +`` +struct A { private: void operator<<(const A&); }; +boost::has_left_shift<A>::value; // error: A::operator<<(const A&) is private +`` + +* There is an issue if the operator exists only for type `A` and `B` is +convertible to `A`. In this case, the compiler will report an ambiguous overload. +`` +struct A { }; +void operator<<(const A&, const A&); +struct B { operator A(); }; +boost::has_left_shift<A>::value; // this is fine +boost::has_left_shift<B>::value; // error: ambiguous overload +`` + +* There is an issue when applying this trait to template classes. +If `operator<<` is defined but does not bind for a given template type, +it is still detected by the trait which returns `true` instead of `false`. +Example: +`` +#include <boost/type_traits/has_left_shift.hpp> +#include <iostream> + +template <class T> +struct contains { T data; }; + +template <class T> +bool operator<<(const contains<T> &lhs, const contains<T> &rhs) { + return f(lhs.data, rhs.data); +} + +class bad { }; +class good { }; +bool f(const good&, const good&) { } + +int main() { + std::cout<<std::boolalpha; + // works fine for contains<good> + std::cout<<boost::has_left_shift< contains< good > >::value<<'\n'; // true + contains<good> g; + g<<g; // ok + // does not work for contains<bad> + std::cout<<boost::has_left_shift< contains< bad > >::value<<'\n'; // true, should be false + contains<bad> b; + b<<b; // compile time error + return 0; +} +`` + +* `volatile` qualifier is not properly handled and would lead to undefined behavior + +[endsect] + diff --git a/libs/type_traits/doc/has_left_shift_assign.qbk b/libs/type_traits/doc/has_left_shift_assign.qbk new file mode 100644 index 0000000000..1981e917b0 --- /dev/null +++ b/libs/type_traits/doc/has_left_shift_assign.qbk @@ -0,0 +1,109 @@ +[/ + (C) Copyright 2009-2011 Frederic Bron. + 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_left_shift_assign has_left_shift_assign] + template <class Lhs, class Rhs=Lhs, class Ret=dont_care> + struct has_left_shift_assign : public __tof {}; + +__inherit +If (i) `lhs` of type `Lhs` and `rhs` of type `Rhs` can be used in expression `lhs<<=rhs`, +and (ii) `Ret=dont_care` or the result of expression `lhs<<=rhs` is convertible to `Ret` +then inherits from __true_type, +otherwise inherits from __false_type. + +The default behaviour (`Ret=dont_care`) is to not check for the return value of binary `operator<<=`. +If `Ret` is different from the default `dont_care` type, the return value is checked to be convertible to `Ret`. +Convertible to `Ret` means that the return value of the operator can be used as argument to a function expecting `Ret`: +`` +void f(Ret); +Lhs lhs; +Rhs rhs; +f(lhs<<=rhs); // is valid if has_left_shift_assign<Lhs, Rhs, Ret>::value==true +`` +If `Ret=void`, the return type is checked to be exactly `void`. + +__header `#include <boost/type_traits/has_left_shift_assign.hpp>` or `#include <boost/type_traits/has_operator.hpp>` or `#include <boost/type_traits.hpp>` + +__examples + +[:`has_left_shift_assign<Lhs, Rhs, Ret>::value_type` is the type `bool`.] +[:`has_left_shift_assign<Lhs, Rhs, Ret>::value` is a `bool` integral constant expression.] +[:`has_left_shift_assign<int>::value` is a `bool` integral constant expression that evaluates to `true`.] +[:`has_left_shift_assign<long>` inherits from `__true_type`.] + +[:`has_left_shift_assign<int, int, int>` inherits from `__true_type`.] + +[:`has_left_shift_assign<const int, int>` inherits from `__false_type`.] +[:`has_left_shift_assign<int, double, bool>` inherits from `__false_type`.] +[:`has_left_shift_assign<int, int, std::string>` inherits from `__false_type`.] + + +[*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits] + +[*Limitation:] + +* Requires a compiler with working SFINAE. + +[*Known issues:] + +* This trait cannot detect whether binary `operator<<=` is public or not: +if `operator<<=` is defined as a private member of `Lhs` then +instantiating `has_left_shift_assign<Lhs>` will produce a compiler error. +For this reason `has_left_shift_assign` cannot be used to determine whether a type has a public `operator<<=` or not. +`` +struct A { private: void operator<<=(const A&); }; +boost::has_left_shift_assign<A>::value; // error: A::operator<<=(const A&) is private +`` + +* There is an issue if the operator exists only for type `A` and `B` is +convertible to `A`. In this case, the compiler will report an ambiguous overload. +`` +struct A { }; +void operator<<=(const A&, const A&); +struct B { operator A(); }; +boost::has_left_shift_assign<A>::value; // this is fine +boost::has_left_shift_assign<B>::value; // error: ambiguous overload +`` + +* There is an issue when applying this trait to template classes. +If `operator<<=` is defined but does not bind for a given template type, +it is still detected by the trait which returns `true` instead of `false`. +Example: +`` +#include <boost/type_traits/has_left_shift_assign.hpp> +#include <iostream> + +template <class T> +struct contains { T data; }; + +template <class T> +bool operator<<=(const contains<T> &lhs, const contains<T> &rhs) { + return f(lhs.data, rhs.data); +} + +class bad { }; +class good { }; +bool f(const good&, const good&) { } + +int main() { + std::cout<<std::boolalpha; + // works fine for contains<good> + std::cout<<boost::has_left_shift_assign< contains< good > >::value<<'\n'; // true + contains<good> g; + g<<=g; // ok + // does not work for contains<bad> + std::cout<<boost::has_left_shift_assign< contains< bad > >::value<<'\n'; // true, should be false + contains<bad> b; + b<<=b; // compile time error + return 0; +} +`` + +* `volatile` qualifier is not properly handled and would lead to undefined behavior + +[endsect] + diff --git a/libs/type_traits/doc/has_less.qbk b/libs/type_traits/doc/has_less.qbk new file mode 100644 index 0000000000..9dbf26daca --- /dev/null +++ b/libs/type_traits/doc/has_less.qbk @@ -0,0 +1,111 @@ +[/ + (C) Copyright 2009-2011 Frederic Bron. + 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_less has_less] + template <class Lhs, class Rhs=Lhs, class Ret=dont_care> + struct has_less : public __tof {}; + +__inherit +If (i) `lhs` of type `Lhs` and `rhs` of type `Rhs` can be used in expression `lhs<rhs`, +and (ii) `Ret=dont_care` or the result of expression `lhs<rhs` is convertible to `Ret` +then inherits from __true_type, +otherwise inherits from __false_type. + +The default behaviour (`Ret=dont_care`) is to not check for the return value of binary `operator<`. +If `Ret` is different from the default `dont_care` type, the return value is checked to be convertible to `Ret`. +Convertible to `Ret` means that the return value of the operator can be used as argument to a function expecting `Ret`: +`` +void f(Ret); +Lhs lhs; +Rhs rhs; +f(lhs<rhs); // is valid if has_less<Lhs, Rhs, Ret>::value==true +`` +If `Ret=void`, the return type is checked to be exactly `void`. + +__header `#include <boost/type_traits/has_less.hpp>` or `#include <boost/type_traits/has_operator.hpp>` or `#include <boost/type_traits.hpp>` + +__examples + +[:`has_less<Lhs, Rhs, Ret>::value_type` is the type `bool`.] +[:`has_less<Lhs, Rhs, Ret>::value` is a `bool` integral constant expression.] +[:`has_less<int>::value` is a `bool` integral constant expression that evaluates to `true`.] +[:`has_less<long>` inherits from `__true_type`.] + +[:`has_less<int, int, bool>` inherits from `__true_type`.] +[:`has_less<int, double, bool>` inherits from `__true_type`.] +[:`has_less<const int>` inherits from `__true_type`.] + +[:`has_less<int*, int>` inherits from `__false_type`.] +[:`has_less<int*, double*>` inherits from `__false_type`.] +[:`has_less<int, int, std::string>` inherits from `__false_type`.] + + +[*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits] + +[*Limitation:] + +* Requires a compiler with working SFINAE. + +[*Known issues:] + +* This trait cannot detect whether binary `operator<` is public or not: +if `operator<` is defined as a private member of `Lhs` then +instantiating `has_less<Lhs>` will produce a compiler error. +For this reason `has_less` cannot be used to determine whether a type has a public `operator<` or not. +`` +struct A { private: void operator<(const A&); }; +boost::has_less<A>::value; // error: A::operator<(const A&) is private +`` + +* There is an issue if the operator exists only for type `A` and `B` is +convertible to `A`. In this case, the compiler will report an ambiguous overload. +`` +struct A { }; +void operator<(const A&, const A&); +struct B { operator A(); }; +boost::has_less<A>::value; // this is fine +boost::has_less<B>::value; // error: ambiguous overload +`` + +* There is an issue when applying this trait to template classes. +If `operator<` is defined but does not bind for a given template type, +it is still detected by the trait which returns `true` instead of `false`. +Example: +`` +#include <boost/type_traits/has_less.hpp> +#include <iostream> + +template <class T> +struct contains { T data; }; + +template <class T> +bool operator<(const contains<T> &lhs, const contains<T> &rhs) { + return f(lhs.data, rhs.data); +} + +class bad { }; +class good { }; +bool f(const good&, const good&) { } + +int main() { + std::cout<<std::boolalpha; + // works fine for contains<good> + std::cout<<boost::has_less< contains< good > >::value<<'\n'; // true + contains<good> g; + g<g; // ok + // does not work for contains<bad> + std::cout<<boost::has_less< contains< bad > >::value<<'\n'; // true, should be false + contains<bad> b; + b<b; // compile time error + return 0; +} +`` + +* `volatile` qualifier is not properly handled and would lead to undefined behavior + +[endsect] + diff --git a/libs/type_traits/doc/has_less_equal.qbk b/libs/type_traits/doc/has_less_equal.qbk new file mode 100644 index 0000000000..832e888fc8 --- /dev/null +++ b/libs/type_traits/doc/has_less_equal.qbk @@ -0,0 +1,111 @@ +[/ + (C) Copyright 2009-2011 Frederic Bron. + 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_less_equal has_less_equal] + template <class Lhs, class Rhs=Lhs, class Ret=dont_care> + struct has_less_equal : public __tof {}; + +__inherit +If (i) `lhs` of type `Lhs` and `rhs` of type `Rhs` can be used in expression `lhs<=rhs`, +and (ii) `Ret=dont_care` or the result of expression `lhs<=rhs` is convertible to `Ret` +then inherits from __true_type, +otherwise inherits from __false_type. + +The default behaviour (`Ret=dont_care`) is to not check for the return value of binary `operator<=`. +If `Ret` is different from the default `dont_care` type, the return value is checked to be convertible to `Ret`. +Convertible to `Ret` means that the return value of the operator can be used as argument to a function expecting `Ret`: +`` +void f(Ret); +Lhs lhs; +Rhs rhs; +f(lhs<=rhs); // is valid if has_less_equal<Lhs, Rhs, Ret>::value==true +`` +If `Ret=void`, the return type is checked to be exactly `void`. + +__header `#include <boost/type_traits/has_less_equal.hpp>` or `#include <boost/type_traits/has_operator.hpp>` or `#include <boost/type_traits.hpp>` + +__examples + +[:`has_less_equal<Lhs, Rhs, Ret>::value_type` is the type `bool`.] +[:`has_less_equal<Lhs, Rhs, Ret>::value` is a `bool` integral constant expression.] +[:`has_less_equal<int>::value` is a `bool` integral constant expression that evaluates to `true`.] +[:`has_less_equal<long>` inherits from `__true_type`.] + +[:`has_less_equal<int, int, bool>` inherits from `__true_type`.] +[:`has_less_equal<int, double, bool>` inherits from `__true_type`.] +[:`has_less_equal<const int>` inherits from `__true_type`.] + +[:`has_less_equal<int*, int>` inherits from `__false_type`.] +[:`has_less_equal<int*, double*>` inherits from `__false_type`.] +[:`has_less_equal<int, int, std::string>` inherits from `__false_type`.] + + +[*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits] + +[*Limitation:] + +* Requires a compiler with working SFINAE. + +[*Known issues:] + +* This trait cannot detect whether binary `operator<=` is public or not: +if `operator<=` is defined as a private member of `Lhs` then +instantiating `has_less_equal<Lhs>` will produce a compiler error. +For this reason `has_less_equal` cannot be used to determine whether a type has a public `operator<=` or not. +`` +struct A { private: void operator<=(const A&); }; +boost::has_less_equal<A>::value; // error: A::operator<=(const A&) is private +`` + +* There is an issue if the operator exists only for type `A` and `B` is +convertible to `A`. In this case, the compiler will report an ambiguous overload. +`` +struct A { }; +void operator<=(const A&, const A&); +struct B { operator A(); }; +boost::has_less_equal<A>::value; // this is fine +boost::has_less_equal<B>::value; // error: ambiguous overload +`` + +* There is an issue when applying this trait to template classes. +If `operator<=` is defined but does not bind for a given template type, +it is still detected by the trait which returns `true` instead of `false`. +Example: +`` +#include <boost/type_traits/has_less_equal.hpp> +#include <iostream> + +template <class T> +struct contains { T data; }; + +template <class T> +bool operator<=(const contains<T> &lhs, const contains<T> &rhs) { + return f(lhs.data, rhs.data); +} + +class bad { }; +class good { }; +bool f(const good&, const good&) { } + +int main() { + std::cout<<std::boolalpha; + // works fine for contains<good> + std::cout<<boost::has_less_equal< contains< good > >::value<<'\n'; // true + contains<good> g; + g<=g; // ok + // does not work for contains<bad> + std::cout<<boost::has_less_equal< contains< bad > >::value<<'\n'; // true, should be false + contains<bad> b; + b<=b; // compile time error + return 0; +} +`` + +* `volatile` qualifier is not properly handled and would lead to undefined behavior + +[endsect] + diff --git a/libs/type_traits/doc/has_logical_and.qbk b/libs/type_traits/doc/has_logical_and.qbk new file mode 100644 index 0000000000..1dfad18fef --- /dev/null +++ b/libs/type_traits/doc/has_logical_and.qbk @@ -0,0 +1,110 @@ +[/ + (C) Copyright 2009-2011 Frederic Bron. + 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_logical_and has_logical_and] + template <class Lhs, class Rhs=Lhs, class Ret=dont_care> + struct has_logical_and : public __tof {}; + +__inherit +If (i) `lhs` of type `Lhs` and `rhs` of type `Rhs` can be used in expression `lhs&&rhs`, +and (ii) `Ret=dont_care` or the result of expression `lhs&&rhs` is convertible to `Ret` +then inherits from __true_type, +otherwise inherits from __false_type. + +The default behaviour (`Ret=dont_care`) is to not check for the return value of binary `operator&&`. +If `Ret` is different from the default `dont_care` type, the return value is checked to be convertible to `Ret`. +Convertible to `Ret` means that the return value of the operator can be used as argument to a function expecting `Ret`: +`` +void f(Ret); +Lhs lhs; +Rhs rhs; +f(lhs&&rhs); // is valid if has_logical_and<Lhs, Rhs, Ret>::value==true +`` +If `Ret=void`, the return type is checked to be exactly `void`. + +__header `#include <boost/type_traits/has_logical_and.hpp>` or `#include <boost/type_traits/has_operator.hpp>` or `#include <boost/type_traits.hpp>` + +__examples + +[:`has_logical_and<Lhs, Rhs, Ret>::value_type` is the type `bool`.] +[:`has_logical_and<Lhs, Rhs, Ret>::value` is a `bool` integral constant expression.] +[:`has_logical_and<int>::value` is a `bool` integral constant expression that evaluates to `true`.] +[:`has_logical_and<bool>` inherits from `__true_type`.] + +[:`has_logical_and<int, int, bool>` inherits from `__true_type`.] +[:`has_logical_and<int, int, long>` inherits from `__true_type`.] +[:`has_logical_and<int, double, bool>` inherits from `__true_type`.] +[:`has_logical_and<const int, int>::value` inherits from `__true_type`.] + +[:`has_logical_and<int, int, std::string>` inherits from `__false_type`.] + + +[*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits] + +[*Limitation:] + +* Requires a compiler with working SFINAE. + +[*Known issues:] + +* This trait cannot detect whether binary `operator&&` is public or not: +if `operator&&` is defined as a private member of `Lhs` then +instantiating `has_logical_and<Lhs>` will produce a compiler error. +For this reason `has_logical_and` cannot be used to determine whether a type has a public `operator&&` or not. +`` +struct A { private: void operator&&(const A&); }; +boost::has_logical_and<A>::value; // error: A::operator&&(const A&) is private +`` + +* There is an issue if the operator exists only for type `A` and `B` is +convertible to `A`. In this case, the compiler will report an ambiguous overload. +`` +struct A { }; +void operator&&(const A&, const A&); +struct B { operator A(); }; +boost::has_logical_and<A>::value; // this is fine +boost::has_logical_and<B>::value; // error: ambiguous overload +`` + +* There is an issue when applying this trait to template classes. +If `operator&&` is defined but does not bind for a given template type, +it is still detected by the trait which returns `true` instead of `false`. +Example: +`` +#include <boost/type_traits/has_logical_and.hpp> +#include <iostream> + +template <class T> +struct contains { T data; }; + +template <class T> +bool operator&&(const contains<T> &lhs, const contains<T> &rhs) { + return f(lhs.data, rhs.data); +} + +class bad { }; +class good { }; +bool f(const good&, const good&) { } + +int main() { + std::cout<<std::boolalpha; + // works fine for contains<good> + std::cout<<boost::has_logical_and< contains< good > >::value<<'\n'; // true + contains<good> g; + g&&g; // ok + // does not work for contains<bad> + std::cout<<boost::has_logical_and< contains< bad > >::value<<'\n'; // true, should be false + contains<bad> b; + b&&b; // compile time error + return 0; +} +`` + +* `volatile` qualifier is not properly handled and would lead to undefined behavior + +[endsect] + diff --git a/libs/type_traits/doc/has_logical_not.qbk b/libs/type_traits/doc/has_logical_not.qbk new file mode 100644 index 0000000000..58fbf3aeaf --- /dev/null +++ b/libs/type_traits/doc/has_logical_not.qbk @@ -0,0 +1,110 @@ +[/ + (C) Copyright 2009-2011 Frederic Bron. + 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_logical_not has_logical_not] + template <class Rhs, class Ret=dont_care> + struct has_logical_not : public __tof {}; + +__inherit +If (i) `rhs` of type `Rhs` can be used in expression `!rhs`, +and (ii) `Ret=dont_care` or the result of expression `!rhs` is convertible to `Ret` +then inherits from __true_type, +otherwise inherits from __false_type. + +The default behaviour (`Ret=dont_care`) is to not check for the return value of prefix `operator!`. +If `Ret` is different from the default `dont_care` type, the return value is checked to be convertible to `Ret`. +Convertible to `Ret` means that the return value of the operator can be used as argument to a function expecting `Ret`: +`` +void f(Ret); +Rhs rhs; +f(!rhs); // is valid if has_logical_not<Rhs, Ret>::value==true +`` +If `Ret=void`, the return type is checked to be exactly `void`. + +__header `#include <boost/type_traits/has_logical_not.hpp>` or `#include <boost/type_traits/has_operator.hpp>` or `#include <boost/type_traits.hpp>` + +__examples + +[:`has_logical_not<Rhs, Ret>::value_type` is the type `bool`.] +[:`has_logical_not<Rhs, Ret>::value` is a `bool` integral constant expression.] +[:`has_logical_not<int>::value` is a `bool` integral constant expression that evaluates to `true`.] +[:`has_logical_not<bool>` inherits from `__true_type`.] + +[:`has_logical_not<int, bool>` inherits from `__true_type`.] +[:`has_logical_not<int, long>` inherits from `__true_type`.] +[:`has_logical_not<double, double>` inherits from `__true_type`.] +[:`has_logical_not<double, bool>` inherits from `__true_type`.] +[:`has_logical_not<const bool>` inherits from `__true_type`.] + +[:`has_logical_not<int, std::string>` inherits from `__false_type`.] + + +[*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits] + +[*Limitation:] + +* Requires a compiler with working SFINAE. + +[*Known issues:] + +* This trait cannot detect whether prefix `operator!` is public or not: +if `operator!` is defined as a private member of `Rhs` then +instantiating `has_logical_not<Rhs>` will produce a compiler error. +For this reason `has_logical_not` cannot be used to determine whether a type has a public `operator!` or not. +`` +struct A { private: void operator!(); }; +boost::has_logical_not<A>::value; // error: A::operator!() is private +`` + +* There is an issue if the operator exists only for type `A` and `B` is +convertible to `A`. In this case, the compiler will report an ambiguous overload. +`` +struct A { }; +void operator!(const A&); +struct B { operator A(); }; +boost::has_logical_not<A>::value; // this is fine +boost::has_logical_not<B>::value; // error: ambiguous overload +`` + +* There is an issue when applying this trait to template classes. +If `operator!` is defined but does not bind for a given template type, +it is still detected by the trait which returns `true` instead of `false`. +Example: +`` +#include <boost/type_traits/has_logical_not.hpp> +#include <iostream> + +template <class T> +struct contains { T data; }; + +template <class T> +bool operator!(const contains<T> &rhs) { + return f(rhs.data); +} + +class bad { }; +class good { }; +bool f(const good&) { } + +int main() { + std::cout<<std::boolalpha; + // works fine for contains<good> + std::cout<<boost::has_logical_not< contains< good > >::value<<'\n'; // true + contains<good> g; + !g; // ok + // does not work for contains<bad> + std::cout<<boost::has_logical_not< contains< bad > >::value<<'\n'; // true, should be false + contains<bad> b; + !b; // compile time error + return 0; +} +`` + +* `volatile` qualifier is not properly handled and would lead to undefined behavior + +[endsect] + diff --git a/libs/type_traits/doc/has_logical_or.qbk b/libs/type_traits/doc/has_logical_or.qbk new file mode 100644 index 0000000000..29affa6999 --- /dev/null +++ b/libs/type_traits/doc/has_logical_or.qbk @@ -0,0 +1,110 @@ +[/ + (C) Copyright 2009-2011 Frederic Bron. + 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_logical_or has_logical_or] + template <class Lhs, class Rhs=Lhs, class Ret=dont_care> + struct has_logical_or : public __tof {}; + +__inherit +If (i) `lhs` of type `Lhs` and `rhs` of type `Rhs` can be used in expression `lhs||rhs`, +and (ii) `Ret=dont_care` or the result of expression `lhs||rhs` is convertible to `Ret` +then inherits from __true_type, +otherwise inherits from __false_type. + +The default behaviour (`Ret=dont_care`) is to not check for the return value of binary `operator||`. +If `Ret` is different from the default `dont_care` type, the return value is checked to be convertible to `Ret`. +Convertible to `Ret` means that the return value of the operator can be used as argument to a function expecting `Ret`: +`` +void f(Ret); +Lhs lhs; +Rhs rhs; +f(lhs||rhs); // is valid if has_logical_or<Lhs, Rhs, Ret>::value==true +`` +If `Ret=void`, the return type is checked to be exactly `void`. + +__header `#include <boost/type_traits/has_logical_or.hpp>` or `#include <boost/type_traits/has_operator.hpp>` or `#include <boost/type_traits.hpp>` + +__examples + +[:`has_logical_or<Lhs, Rhs, Ret>::value_type` is the type `bool`.] +[:`has_logical_or<Lhs, Rhs, Ret>::value` is a `bool` integral constant expression.] +[:`has_logical_or<int>::value` is a `bool` integral constant expression that evaluates to `true`.] +[:`has_logical_or<bool>` inherits from `__true_type`.] + +[:`has_logical_or<int, int, bool>` inherits from `__true_type`.] +[:`has_logical_or<int, int, long>` inherits from `__true_type`.] +[:`has_logical_or<int, double, bool>` inherits from `__true_type`.] +[:`has_logical_or<const int, int>::value` inherits from `__true_type`.] + +[:`has_logical_or<int, int, std::string>` inherits from `__false_type`.] + + +[*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits] + +[*Limitation:] + +* Requires a compiler with working SFINAE. + +[*Known issues:] + +* This trait cannot detect whether binary `operator||` is public or not: +if `operator||` is defined as a private member of `Lhs` then +instantiating `has_logical_or<Lhs>` will produce a compiler error. +For this reason `has_logical_or` cannot be used to determine whether a type has a public `operator||` or not. +`` +struct A { private: void operator||(const A&); }; +boost::has_logical_or<A>::value; // error: A::operator||(const A&) is private +`` + +* There is an issue if the operator exists only for type `A` and `B` is +convertible to `A`. In this case, the compiler will report an ambiguous overload. +`` +struct A { }; +void operator||(const A&, const A&); +struct B { operator A(); }; +boost::has_logical_or<A>::value; // this is fine +boost::has_logical_or<B>::value; // error: ambiguous overload +`` + +* There is an issue when applying this trait to template classes. +If `operator||` is defined but does not bind for a given template type, +it is still detected by the trait which returns `true` instead of `false`. +Example: +`` +#include <boost/type_traits/has_logical_or.hpp> +#include <iostream> + +template <class T> +struct contains { T data; }; + +template <class T> +bool operator||(const contains<T> &lhs, const contains<T> &rhs) { + return f(lhs.data, rhs.data); +} + +class bad { }; +class good { }; +bool f(const good&, const good&) { } + +int main() { + std::cout<<std::boolalpha; + // works fine for contains<good> + std::cout<<boost::has_logical_or< contains< good > >::value<<'\n'; // true + contains<good> g; + g||g; // ok + // does not work for contains<bad> + std::cout<<boost::has_logical_or< contains< bad > >::value<<'\n'; // true, should be false + contains<bad> b; + b||b; // compile time error + return 0; +} +`` + +* `volatile` qualifier is not properly handled and would lead to undefined behavior + +[endsect] + diff --git a/libs/type_traits/doc/has_minus.qbk b/libs/type_traits/doc/has_minus.qbk new file mode 100644 index 0000000000..fdf4d9a6fe --- /dev/null +++ b/libs/type_traits/doc/has_minus.qbk @@ -0,0 +1,111 @@ +[/ + (C) Copyright 2009-2011 Frederic Bron. + 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_minus has_minus] + template <class Lhs, class Rhs=Lhs, class Ret=dont_care> + struct has_minus : public __tof {}; + +__inherit +If (i) `lhs` of type `Lhs` and `rhs` of type `Rhs` can be used in expression `lhs-rhs`, +and (ii) `Ret=dont_care` or the result of expression `lhs-rhs` is convertible to `Ret` +then inherits from __true_type, +otherwise inherits from __false_type. + +The default behaviour (`Ret=dont_care`) is to not check for the return value of binary `operator-`. +If `Ret` is different from the default `dont_care` type, the return value is checked to be convertible to `Ret`. +Convertible to `Ret` means that the return value of the operator can be used as argument to a function expecting `Ret`: +`` +void f(Ret); +Lhs lhs; +Rhs rhs; +f(lhs-rhs); // is valid if has_minus<Lhs, Rhs, Ret>::value==true +`` +If `Ret=void`, the return type is checked to be exactly `void`. + +__header `#include <boost/type_traits/has_minus.hpp>` or `#include <boost/type_traits/has_operator.hpp>` or `#include <boost/type_traits.hpp>` + +__examples + +[:`has_minus<Lhs, Rhs, Ret>::value_type` is the type `bool`.] +[:`has_minus<Lhs, Rhs, Ret>::value` is a `bool` integral constant expression.] +[:`has_minus<int>::value` is a `bool` integral constant expression that evaluates to `true`.] +[:`has_minus<long>` inherits from `__true_type`.] + +[:`has_minus<int, int, int>` inherits from `__true_type`.] +[:`has_minus<int, int, long>` inherits from `__true_type`.] +[:`has_minus<int, double, double>` inherits from `__true_type`.] +[:`has_minus<int, double, int>` inherits from `__true_type`.] +[:`has_minus<const int, int>::value` inherits from `__true_type`.] + +[:`has_minus<int, int, std::string>` inherits from `__false_type`.] + + +[*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits] + +[*Limitation:] + +* Requires a compiler with working SFINAE. + +[*Known issues:] + +* This trait cannot detect whether binary `operator-` is public or not: +if `operator-` is defined as a private member of `Lhs` then +instantiating `has_minus<Lhs>` will produce a compiler error. +For this reason `has_minus` cannot be used to determine whether a type has a public `operator-` or not. +`` +struct A { private: void operator-(const A&); }; +boost::has_minus<A>::value; // error: A::operator-(const A&) is private +`` + +* There is an issue if the operator exists only for type `A` and `B` is +convertible to `A`. In this case, the compiler will report an ambiguous overload. +`` +struct A { }; +void operator-(const A&, const A&); +struct B { operator A(); }; +boost::has_minus<A>::value; // this is fine +boost::has_minus<B>::value; // error: ambiguous overload +`` + +* There is an issue when applying this trait to template classes. +If `operator-` is defined but does not bind for a given template type, +it is still detected by the trait which returns `true` instead of `false`. +Example: +`` +#include <boost/type_traits/has_minus.hpp> +#include <iostream> + +template <class T> +struct contains { T data; }; + +template <class T> +bool operator-(const contains<T> &lhs, const contains<T> &rhs) { + return f(lhs.data, rhs.data); +} + +class bad { }; +class good { }; +bool f(const good&, const good&) { } + +int main() { + std::cout<<std::boolalpha; + // works fine for contains<good> + std::cout<<boost::has_minus< contains< good > >::value<<'\n'; // true + contains<good> g; + g-g; // ok + // does not work for contains<bad> + std::cout<<boost::has_minus< contains< bad > >::value<<'\n'; // true, should be false + contains<bad> b; + b-b; // compile time error + return 0; +} +`` + +* `volatile` qualifier is not properly handled and would lead to undefined behavior + +[endsect] + diff --git a/libs/type_traits/doc/has_minus_assign.qbk b/libs/type_traits/doc/has_minus_assign.qbk new file mode 100644 index 0000000000..cbb4cba8ca --- /dev/null +++ b/libs/type_traits/doc/has_minus_assign.qbk @@ -0,0 +1,111 @@ +[/ + (C) Copyright 2009-2011 Frederic Bron. + 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_minus_assign has_minus_assign] + template <class Lhs, class Rhs=Lhs, class Ret=dont_care> + struct has_minus_assign : public __tof {}; + +__inherit +If (i) `lhs` of type `Lhs` and `rhs` of type `Rhs` can be used in expression `lhs-=rhs`, +and (ii) `Ret=dont_care` or the result of expression `lhs-=rhs` is convertible to `Ret` +then inherits from __true_type, +otherwise inherits from __false_type. + +The default behaviour (`Ret=dont_care`) is to not check for the return value of binary `operator-=`. +If `Ret` is different from the default `dont_care` type, the return value is checked to be convertible to `Ret`. +Convertible to `Ret` means that the return value of the operator can be used as argument to a function expecting `Ret`: +`` +void f(Ret); +Lhs lhs; +Rhs rhs; +f(lhs-=rhs); // is valid if has_minus_assign<Lhs, Rhs, Ret>::value==true +`` +If `Ret=void`, the return type is checked to be exactly `void`. + +__header `#include <boost/type_traits/has_minus_assign.hpp>` or `#include <boost/type_traits/has_operator.hpp>` or `#include <boost/type_traits.hpp>` + +__examples + +[:`has_minus_assign<Lhs, Rhs, Ret>::value_type` is the type `bool`.] +[:`has_minus_assign<Lhs, Rhs, Ret>::value` is a `bool` integral constant expression.] +[:`has_minus_assign<int>::value` is a `bool` integral constant expression that evaluates to `true`.] +[:`has_minus_assign<long>` inherits from `__true_type`.] + +[:`has_minus_assign<int, int, int>` inherits from `__true_type`.] +[:`has_minus_assign<int, int, long>` inherits from `__true_type`.] +[:`has_minus_assign<int, double, double>` inherits from `__true_type`.] +[:`has_minus_assign<int, double, int>` inherits from `__true_type`.] + +[:`has_minus_assign<const int, int>::value` inherits from `__false_type`.] +[:`has_minus_assign<int, int, std::string>` inherits from `__false_type`.] + + +[*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits] + +[*Limitation:] + +* Requires a compiler with working SFINAE. + +[*Known issues:] + +* This trait cannot detect whether binary `operator-=` is public or not: +if `operator-=` is defined as a private member of `Lhs` then +instantiating `has_minus_assign<Lhs>` will produce a compiler error. +For this reason `has_minus_assign` cannot be used to determine whether a type has a public `operator-=` or not. +`` +struct A { private: void operator-=(const A&); }; +boost::has_minus_assign<A>::value; // error: A::operator-=(const A&) is private +`` + +* There is an issue if the operator exists only for type `A` and `B` is +convertible to `A`. In this case, the compiler will report an ambiguous overload. +`` +struct A { }; +void operator-=(const A&, const A&); +struct B { operator A(); }; +boost::has_minus_assign<A>::value; // this is fine +boost::has_minus_assign<B>::value; // error: ambiguous overload +`` + +* There is an issue when applying this trait to template classes. +If `operator-=` is defined but does not bind for a given template type, +it is still detected by the trait which returns `true` instead of `false`. +Example: +`` +#include <boost/type_traits/has_minus_assign.hpp> +#include <iostream> + +template <class T> +struct contains { T data; }; + +template <class T> +bool operator-=(const contains<T> &lhs, const contains<T> &rhs) { + return f(lhs.data, rhs.data); +} + +class bad { }; +class good { }; +bool f(const good&, const good&) { } + +int main() { + std::cout<<std::boolalpha; + // works fine for contains<good> + std::cout<<boost::has_minus_assign< contains< good > >::value<<'\n'; // true + contains<good> g; + g-=g; // ok + // does not work for contains<bad> + std::cout<<boost::has_minus_assign< contains< bad > >::value<<'\n'; // true, should be false + contains<bad> b; + b-=b; // compile time error + return 0; +} +`` + +* `volatile` qualifier is not properly handled and would lead to undefined behavior + +[endsect] + diff --git a/libs/type_traits/doc/has_modulus.qbk b/libs/type_traits/doc/has_modulus.qbk new file mode 100644 index 0000000000..589f3b1647 --- /dev/null +++ b/libs/type_traits/doc/has_modulus.qbk @@ -0,0 +1,109 @@ +[/ + (C) Copyright 2009-2011 Frederic Bron. + 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_modulus has_modulus] + template <class Lhs, class Rhs=Lhs, class Ret=dont_care> + struct has_modulus : public __tof {}; + +__inherit +If (i) `lhs` of type `Lhs` and `rhs` of type `Rhs` can be used in expression `lhs%rhs`, +and (ii) `Ret=dont_care` or the result of expression `lhs%rhs` is convertible to `Ret` +then inherits from __true_type, +otherwise inherits from __false_type. + +The default behaviour (`Ret=dont_care`) is to not check for the return value of binary `operator%`. +If `Ret` is different from the default `dont_care` type, the return value is checked to be convertible to `Ret`. +Convertible to `Ret` means that the return value of the operator can be used as argument to a function expecting `Ret`: +`` +void f(Ret); +Lhs lhs; +Rhs rhs; +f(lhs%rhs); // is valid if has_modulus<Lhs, Rhs, Ret>::value==true +`` +If `Ret=void`, the return type is checked to be exactly `void`. + +__header `#include <boost/type_traits/has_modulus.hpp>` or `#include <boost/type_traits/has_operator.hpp>` or `#include <boost/type_traits.hpp>` + +__examples + +[:`has_modulus<Lhs, Rhs, Ret>::value_type` is the type `bool`.] +[:`has_modulus<Lhs, Rhs, Ret>::value` is a `bool` integral constant expression.] +[:`has_modulus<int>::value` is a `bool` integral constant expression that evaluates to `true`.] +[:`has_modulus<long>` inherits from `__true_type`.] + +[:`has_modulus<int, int, int>` inherits from `__true_type`.] +[:`has_modulus<int, int, long>` inherits from `__true_type`.] +[:`has_modulus<const int, int>::value` inherits from `__true_type`.] + +[:`has_modulus<int, double>` inherits from `__false_type`.] + + +[*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits] + +[*Limitation:] + +* Requires a compiler with working SFINAE. + +[*Known issues:] + +* This trait cannot detect whether binary `operator%` is public or not: +if `operator%` is defined as a private member of `Lhs` then +instantiating `has_modulus<Lhs>` will produce a compiler error. +For this reason `has_modulus` cannot be used to determine whether a type has a public `operator%` or not. +`` +struct A { private: void operator%(const A&); }; +boost::has_modulus<A>::value; // error: A::operator%(const A&) is private +`` + +* There is an issue if the operator exists only for type `A` and `B` is +convertible to `A`. In this case, the compiler will report an ambiguous overload. +`` +struct A { }; +void operator%(const A&, const A&); +struct B { operator A(); }; +boost::has_modulus<A>::value; // this is fine +boost::has_modulus<B>::value; // error: ambiguous overload +`` + +* There is an issue when applying this trait to template classes. +If `operator%` is defined but does not bind for a given template type, +it is still detected by the trait which returns `true` instead of `false`. +Example: +`` +#include <boost/type_traits/has_modulus.hpp> +#include <iostream> + +template <class T> +struct contains { T data; }; + +template <class T> +bool operator%(const contains<T> &lhs, const contains<T> &rhs) { + return f(lhs.data, rhs.data); +} + +class bad { }; +class good { }; +bool f(const good&, const good&) { } + +int main() { + std::cout<<std::boolalpha; + // works fine for contains<good> + std::cout<<boost::has_modulus< contains< good > >::value<<'\n'; // true + contains<good> g; + g%g; // ok + // does not work for contains<bad> + std::cout<<boost::has_modulus< contains< bad > >::value<<'\n'; // true, should be false + contains<bad> b; + b%b; // compile time error + return 0; +} +`` + +* `volatile` qualifier is not properly handled and would lead to undefined behavior + +[endsect] + diff --git a/libs/type_traits/doc/has_modulus_assign.qbk b/libs/type_traits/doc/has_modulus_assign.qbk new file mode 100644 index 0000000000..4441a70fc9 --- /dev/null +++ b/libs/type_traits/doc/has_modulus_assign.qbk @@ -0,0 +1,109 @@ +[/ + (C) Copyright 2009-2011 Frederic Bron. + 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_modulus_assign has_modulus_assign] + template <class Lhs, class Rhs=Lhs, class Ret=dont_care> + struct has_modulus_assign : public __tof {}; + +__inherit +If (i) `lhs` of type `Lhs` and `rhs` of type `Rhs` can be used in expression `lhs%=rhs`, +and (ii) `Ret=dont_care` or the result of expression `lhs%=rhs` is convertible to `Ret` +then inherits from __true_type, +otherwise inherits from __false_type. + +The default behaviour (`Ret=dont_care`) is to not check for the return value of binary `operator%=`. +If `Ret` is different from the default `dont_care` type, the return value is checked to be convertible to `Ret`. +Convertible to `Ret` means that the return value of the operator can be used as argument to a function expecting `Ret`: +`` +void f(Ret); +Lhs lhs; +Rhs rhs; +f(lhs%=rhs); // is valid if has_modulus_assign<Lhs, Rhs, Ret>::value==true +`` +If `Ret=void`, the return type is checked to be exactly `void`. + +__header `#include <boost/type_traits/has_modulus_assign.hpp>` or `#include <boost/type_traits/has_operator.hpp>` or `#include <boost/type_traits.hpp>` + +__examples + +[:`has_modulus_assign<Lhs, Rhs, Ret>::value_type` is the type `bool`.] +[:`has_modulus_assign<Lhs, Rhs, Ret>::value` is a `bool` integral constant expression.] +[:`has_modulus_assign<int>::value` is a `bool` integral constant expression that evaluates to `true`.] +[:`has_modulus_assign<long>` inherits from `__true_type`.] + +[:`has_modulus_assign<int, int, int>` inherits from `__true_type`.] +[:`has_modulus_assign<int, int, long>` inherits from `__true_type`.] + +[:`has_modulus_assign<const int, int>::value` inherits from `__false_type`.] +[:`has_modulus_assign<int, double>` inherits from `__false_type`.] + + +[*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits] + +[*Limitation:] + +* Requires a compiler with working SFINAE. + +[*Known issues:] + +* This trait cannot detect whether binary `operator%=` is public or not: +if `operator%=` is defined as a private member of `Lhs` then +instantiating `has_modulus_assign<Lhs>` will produce a compiler error. +For this reason `has_modulus_assign` cannot be used to determine whether a type has a public `operator%=` or not. +`` +struct A { private: void operator%=(const A&); }; +boost::has_modulus_assign<A>::value; // error: A::operator%=(const A&) is private +`` + +* There is an issue if the operator exists only for type `A` and `B` is +convertible to `A`. In this case, the compiler will report an ambiguous overload. +`` +struct A { }; +void operator%=(const A&, const A&); +struct B { operator A(); }; +boost::has_modulus_assign<A>::value; // this is fine +boost::has_modulus_assign<B>::value; // error: ambiguous overload +`` + +* There is an issue when applying this trait to template classes. +If `operator%=` is defined but does not bind for a given template type, +it is still detected by the trait which returns `true` instead of `false`. +Example: +`` +#include <boost/type_traits/has_modulus_assign.hpp> +#include <iostream> + +template <class T> +struct contains { T data; }; + +template <class T> +bool operator%=(const contains<T> &lhs, const contains<T> &rhs) { + return f(lhs.data, rhs.data); +} + +class bad { }; +class good { }; +bool f(const good&, const good&) { } + +int main() { + std::cout<<std::boolalpha; + // works fine for contains<good> + std::cout<<boost::has_modulus_assign< contains< good > >::value<<'\n'; // true + contains<good> g; + g%=g; // ok + // does not work for contains<bad> + std::cout<<boost::has_modulus_assign< contains< bad > >::value<<'\n'; // true, should be false + contains<bad> b; + b%=b; // compile time error + return 0; +} +`` + +* `volatile` qualifier is not properly handled and would lead to undefined behavior + +[endsect] + diff --git a/libs/type_traits/doc/has_multiplies.qbk b/libs/type_traits/doc/has_multiplies.qbk new file mode 100644 index 0000000000..9eaea40504 --- /dev/null +++ b/libs/type_traits/doc/has_multiplies.qbk @@ -0,0 +1,111 @@ +[/ + (C) Copyright 2009-2011 Frederic Bron. + 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_multiplies has_multiplies] + template <class Lhs, class Rhs=Lhs, class Ret=dont_care> + struct has_multiplies : public __tof {}; + +__inherit +If (i) `lhs` of type `Lhs` and `rhs` of type `Rhs` can be used in expression `lhs*rhs`, +and (ii) `Ret=dont_care` or the result of expression `lhs*rhs` is convertible to `Ret` +then inherits from __true_type, +otherwise inherits from __false_type. + +The default behaviour (`Ret=dont_care`) is to not check for the return value of binary `operator*`. +If `Ret` is different from the default `dont_care` type, the return value is checked to be convertible to `Ret`. +Convertible to `Ret` means that the return value of the operator can be used as argument to a function expecting `Ret`: +`` +void f(Ret); +Lhs lhs; +Rhs rhs; +f(lhs*rhs); // is valid if has_multiplies<Lhs, Rhs, Ret>::value==true +`` +If `Ret=void`, the return type is checked to be exactly `void`. + +__header `#include <boost/type_traits/has_multiplies.hpp>` or `#include <boost/type_traits/has_operator.hpp>` or `#include <boost/type_traits.hpp>` + +__examples + +[:`has_multiplies<Lhs, Rhs, Ret>::value_type` is the type `bool`.] +[:`has_multiplies<Lhs, Rhs, Ret>::value` is a `bool` integral constant expression.] +[:`has_multiplies<int>::value` is a `bool` integral constant expression that evaluates to `true`.] +[:`has_multiplies<long>` inherits from `__true_type`.] + +[:`has_multiplies<int, int, int>` inherits from `__true_type`.] +[:`has_multiplies<int, int, long>` inherits from `__true_type`.] +[:`has_multiplies<int, double, double>` inherits from `__true_type`.] +[:`has_multiplies<int, double, int>` inherits from `__true_type`.] +[:`has_multiplies<const int, int>::value` inherits from `__true_type`.] + +[:`has_multiplies<int, int, std::string>` inherits from `__false_type`.] + + +[*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits] + +[*Limitation:] + +* Requires a compiler with working SFINAE. + +[*Known issues:] + +* This trait cannot detect whether binary `operator*` is public or not: +if `operator*` is defined as a private member of `Lhs` then +instantiating `has_multiplies<Lhs>` will produce a compiler error. +For this reason `has_multiplies` cannot be used to determine whether a type has a public `operator*` or not. +`` +struct A { private: void operator*(const A&); }; +boost::has_multiplies<A>::value; // error: A::operator*(const A&) is private +`` + +* There is an issue if the operator exists only for type `A` and `B` is +convertible to `A`. In this case, the compiler will report an ambiguous overload. +`` +struct A { }; +void operator*(const A&, const A&); +struct B { operator A(); }; +boost::has_multiplies<A>::value; // this is fine +boost::has_multiplies<B>::value; // error: ambiguous overload +`` + +* There is an issue when applying this trait to template classes. +If `operator*` is defined but does not bind for a given template type, +it is still detected by the trait which returns `true` instead of `false`. +Example: +`` +#include <boost/type_traits/has_multiplies.hpp> +#include <iostream> + +template <class T> +struct contains { T data; }; + +template <class T> +bool operator*(const contains<T> &lhs, const contains<T> &rhs) { + return f(lhs.data, rhs.data); +} + +class bad { }; +class good { }; +bool f(const good&, const good&) { } + +int main() { + std::cout<<std::boolalpha; + // works fine for contains<good> + std::cout<<boost::has_multiplies< contains< good > >::value<<'\n'; // true + contains<good> g; + g*g; // ok + // does not work for contains<bad> + std::cout<<boost::has_multiplies< contains< bad > >::value<<'\n'; // true, should be false + contains<bad> b; + b*b; // compile time error + return 0; +} +`` + +* `volatile` qualifier is not properly handled and would lead to undefined behavior + +[endsect] + diff --git a/libs/type_traits/doc/has_multiplies_assign.qbk b/libs/type_traits/doc/has_multiplies_assign.qbk new file mode 100644 index 0000000000..91b45e92e2 --- /dev/null +++ b/libs/type_traits/doc/has_multiplies_assign.qbk @@ -0,0 +1,111 @@ +[/ + (C) Copyright 2009-2011 Frederic Bron. + 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_multiplies_assign has_multiplies_assign] + template <class Lhs, class Rhs=Lhs, class Ret=dont_care> + struct has_multiplies_assign : public __tof {}; + +__inherit +If (i) `lhs` of type `Lhs` and `rhs` of type `Rhs` can be used in expression `lhs*=rhs`, +and (ii) `Ret=dont_care` or the result of expression `lhs*=rhs` is convertible to `Ret` +then inherits from __true_type, +otherwise inherits from __false_type. + +The default behaviour (`Ret=dont_care`) is to not check for the return value of binary `operator*=`. +If `Ret` is different from the default `dont_care` type, the return value is checked to be convertible to `Ret`. +Convertible to `Ret` means that the return value of the operator can be used as argument to a function expecting `Ret`: +`` +void f(Ret); +Lhs lhs; +Rhs rhs; +f(lhs*=rhs); // is valid if has_multiplies_assign<Lhs, Rhs, Ret>::value==true +`` +If `Ret=void`, the return type is checked to be exactly `void`. + +__header `#include <boost/type_traits/has_multiplies_assign.hpp>` or `#include <boost/type_traits/has_operator.hpp>` or `#include <boost/type_traits.hpp>` + +__examples + +[:`has_multiplies_assign<Lhs, Rhs, Ret>::value_type` is the type `bool`.] +[:`has_multiplies_assign<Lhs, Rhs, Ret>::value` is a `bool` integral constant expression.] +[:`has_multiplies_assign<int>::value` is a `bool` integral constant expression that evaluates to `true`.] +[:`has_multiplies_assign<long>` inherits from `__true_type`.] + +[:`has_multiplies_assign<int, int, int>` inherits from `__true_type`.] +[:`has_multiplies_assign<int, int, long>` inherits from `__true_type`.] +[:`has_multiplies_assign<int, double, double>` inherits from `__true_type`.] +[:`has_multiplies_assign<int, double, int>` inherits from `__true_type`.] + +[:`has_multiplies_assign<const int, int>::value` inherits from `__false_type`.] +[:`has_multiplies_assign<int, int, std::string>` inherits from `__false_type`.] + + +[*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits] + +[*Limitation:] + +* Requires a compiler with working SFINAE. + +[*Known issues:] + +* This trait cannot detect whether binary `operator*=` is public or not: +if `operator*=` is defined as a private member of `Lhs` then +instantiating `has_multiplies_assign<Lhs>` will produce a compiler error. +For this reason `has_multiplies_assign` cannot be used to determine whether a type has a public `operator*=` or not. +`` +struct A { private: void operator*=(const A&); }; +boost::has_multiplies_assign<A>::value; // error: A::operator*=(const A&) is private +`` + +* There is an issue if the operator exists only for type `A` and `B` is +convertible to `A`. In this case, the compiler will report an ambiguous overload. +`` +struct A { }; +void operator*=(const A&, const A&); +struct B { operator A(); }; +boost::has_multiplies_assign<A>::value; // this is fine +boost::has_multiplies_assign<B>::value; // error: ambiguous overload +`` + +* There is an issue when applying this trait to template classes. +If `operator*=` is defined but does not bind for a given template type, +it is still detected by the trait which returns `true` instead of `false`. +Example: +`` +#include <boost/type_traits/has_multiplies_assign.hpp> +#include <iostream> + +template <class T> +struct contains { T data; }; + +template <class T> +bool operator*=(const contains<T> &lhs, const contains<T> &rhs) { + return f(lhs.data, rhs.data); +} + +class bad { }; +class good { }; +bool f(const good&, const good&) { } + +int main() { + std::cout<<std::boolalpha; + // works fine for contains<good> + std::cout<<boost::has_multiplies_assign< contains< good > >::value<<'\n'; // true + contains<good> g; + g*=g; // ok + // does not work for contains<bad> + std::cout<<boost::has_multiplies_assign< contains< bad > >::value<<'\n'; // true, should be false + contains<bad> b; + b*=b; // compile time error + return 0; +} +`` + +* `volatile` qualifier is not properly handled and would lead to undefined behavior + +[endsect] + diff --git a/libs/type_traits/doc/has_negate.qbk b/libs/type_traits/doc/has_negate.qbk new file mode 100644 index 0000000000..15ea477b2c --- /dev/null +++ b/libs/type_traits/doc/has_negate.qbk @@ -0,0 +1,110 @@ +[/ + (C) Copyright 2009-2011 Frederic Bron. + 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_negate has_negate] + template <class Rhs, class Ret=dont_care> + struct has_negate : public __tof {}; + +__inherit +If (i) `rhs` of type `Rhs` can be used in expression `-rhs`, +and (ii) `Ret=dont_care` or the result of expression `-rhs` is convertible to `Ret` +then inherits from __true_type, +otherwise inherits from __false_type. + +The default behaviour (`Ret=dont_care`) is to not check for the return value of prefix `operator-`. +If `Ret` is different from the default `dont_care` type, the return value is checked to be convertible to `Ret`. +Convertible to `Ret` means that the return value of the operator can be used as argument to a function expecting `Ret`: +`` +void f(Ret); +Rhs rhs; +f(-rhs); // is valid if has_negate<Rhs, Ret>::value==true +`` +If `Ret=void`, the return type is checked to be exactly `void`. + +__header `#include <boost/type_traits/has_negate.hpp>` or `#include <boost/type_traits/has_operator.hpp>` or `#include <boost/type_traits.hpp>` + +__examples + +[:`has_negate<Rhs, Ret>::value_type` is the type `bool`.] +[:`has_negate<Rhs, Ret>::value` is a `bool` integral constant expression.] +[:`has_negate<int>::value` is a `bool` integral constant expression that evaluates to `true`.] +[:`has_negate<long>` inherits from `__true_type`.] + +[:`has_negate<int, int>` inherits from `__true_type`.] +[:`has_negate<int, long>` inherits from `__true_type`.] +[:`has_negate<double, double>` inherits from `__true_type`.] +[:`has_negate<double, int>` inherits from `__true_type`.] +[:`has_negate<const int>` inherits from `__true_type`.] + +[:`has_negate<int, std::string>` inherits from `__false_type`.] + + +[*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits] + +[*Limitation:] + +* Requires a compiler with working SFINAE. + +[*Known issues:] + +* This trait cannot detect whether prefix `operator-` is public or not: +if `operator-` is defined as a private member of `Rhs` then +instantiating `has_negate<Rhs>` will produce a compiler error. +For this reason `has_negate` cannot be used to determine whether a type has a public `operator-` or not. +`` +struct A { private: void operator-(); }; +boost::has_negate<A>::value; // error: A::operator-() is private +`` + +* There is an issue if the operator exists only for type `A` and `B` is +convertible to `A`. In this case, the compiler will report an ambiguous overload. +`` +struct A { }; +void operator-(const A&); +struct B { operator A(); }; +boost::has_negate<A>::value; // this is fine +boost::has_negate<B>::value; // error: ambiguous overload +`` + +* There is an issue when applying this trait to template classes. +If `operator-` is defined but does not bind for a given template type, +it is still detected by the trait which returns `true` instead of `false`. +Example: +`` +#include <boost/type_traits/has_negate.hpp> +#include <iostream> + +template <class T> +struct contains { T data; }; + +template <class T> +bool operator-(const contains<T> &rhs) { + return f(rhs.data); +} + +class bad { }; +class good { }; +bool f(const good&) { } + +int main() { + std::cout<<std::boolalpha; + // works fine for contains<good> + std::cout<<boost::has_negate< contains< good > >::value<<'\n'; // true + contains<good> g; + -g; // ok + // does not work for contains<bad> + std::cout<<boost::has_negate< contains< bad > >::value<<'\n'; // true, should be false + contains<bad> b; + -b; // compile time error + return 0; +} +`` + +* `volatile` qualifier is not properly handled and would lead to undefined behavior + +[endsect] + diff --git a/libs/type_traits/doc/has_new_operator.qbk b/libs/type_traits/doc/has_new_operator.qbk new file mode 100644 index 0000000000..72e0d4c5ee --- /dev/null +++ b/libs/type_traits/doc/has_new_operator.qbk @@ -0,0 +1,49 @@ +[/ + Copyright 2009 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_new_operator has_new_operator] + template <class T> + struct has_new_operator : public __tof {}; + +__inherit If T is a (possibly cv-qualified) type with an overloaded new-operator +then inherits from __true_type, otherwise inherits from __false_type. + +__compat Not usable with compilers that do not support "substitution failure is not an error" +(in which case BOOST_NO_SFINAE will be defined), also known to be broken with +the Borland/Codegear compiler. + +__std_ref 12.5. + +__header ` #include <boost/type_traits/has_new_operator.hpp>` or ` #include <boost/type_traits.hpp>` + +__examples + +Given: + + class A { void* operator new(std::size_t); }; + class B { void* operator new(std::size_t, const std::nothrow&); }; + class C { void* operator new(std::size_t, void*); }; + class D { void* operator new[](std::size_t); }; + class E { void* operator new[](std::size_t, const std::nothrow&); }; + class F { void* operator new[](std::size_t, void*); }; + +Then: + +[:`has_new_operator<A>` inherits from `__true_type`.] + +[:`has_new_operator<B>` inherits from `__true_type`.] + +[:`has_new_operator<C>` inherits from `__true_type`.] + +[:`has_new_operator<D>` inherits from `__true_type`.] + +[:`has_new_operator<E>` inherits from `__true_type`.] + +[:`has_new_operator<F>` inherits from `__true_type`.] + +[endsect] + diff --git a/libs/type_traits/doc/has_not_equal_to.qbk b/libs/type_traits/doc/has_not_equal_to.qbk new file mode 100644 index 0000000000..36626c57cc --- /dev/null +++ b/libs/type_traits/doc/has_not_equal_to.qbk @@ -0,0 +1,111 @@ +[/ + (C) Copyright 2009-2011 Frederic Bron. + 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_not_equal_to has_not_equal_to] + template <class Lhs, class Rhs=Lhs, class Ret=dont_care> + struct has_not_equal_to : public __tof {}; + +__inherit +If (i) `lhs` of type `Lhs` and `rhs` of type `Rhs` can be used in expression `lhs!=rhs`, +and (ii) `Ret=dont_care` or the result of expression `lhs!=rhs` is convertible to `Ret` +then inherits from __true_type, +otherwise inherits from __false_type. + +The default behaviour (`Ret=dont_care`) is to not check for the return value of binary `operator!=`. +If `Ret` is different from the default `dont_care` type, the return value is checked to be convertible to `Ret`. +Convertible to `Ret` means that the return value of the operator can be used as argument to a function expecting `Ret`: +`` +void f(Ret); +Lhs lhs; +Rhs rhs; +f(lhs!=rhs); // is valid if has_not_equal_to<Lhs, Rhs, Ret>::value==true +`` +If `Ret=void`, the return type is checked to be exactly `void`. + +__header `#include <boost/type_traits/has_not_equal_to.hpp>` or `#include <boost/type_traits/has_operator.hpp>` or `#include <boost/type_traits.hpp>` + +__examples + +[:`has_not_equal_to<Lhs, Rhs, Ret>::value_type` is the type `bool`.] +[:`has_not_equal_to<Lhs, Rhs, Ret>::value` is a `bool` integral constant expression.] +[:`has_not_equal_to<int>::value` is a `bool` integral constant expression that evaluates to `true`.] +[:`has_not_equal_to<long>` inherits from `__true_type`.] + +[:`has_not_equal_to<int, int, bool>` inherits from `__true_type`.] +[:`has_not_equal_to<int, double, bool>` inherits from `__true_type`.] +[:`has_not_equal_to<const int>` inherits from `__true_type`.] + +[:`has_not_equal_to<int*, int>` inherits from `__false_type`.] +[:`has_not_equal_to<int*, double*>` inherits from `__false_type`.] +[:`has_not_equal_to<int, int, std::string>` inherits from `__false_type`.] + + +[*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits] + +[*Limitation:] + +* Requires a compiler with working SFINAE. + +[*Known issues:] + +* This trait cannot detect whether binary `operator!=` is public or not: +if `operator!=` is defined as a private member of `Lhs` then +instantiating `has_not_equal_to<Lhs>` will produce a compiler error. +For this reason `has_not_equal_to` cannot be used to determine whether a type has a public `operator!=` or not. +`` +struct A { private: void operator!=(const A&); }; +boost::has_not_equal_to<A>::value; // error: A::operator!=(const A&) is private +`` + +* There is an issue if the operator exists only for type `A` and `B` is +convertible to `A`. In this case, the compiler will report an ambiguous overload. +`` +struct A { }; +void operator!=(const A&, const A&); +struct B { operator A(); }; +boost::has_not_equal_to<A>::value; // this is fine +boost::has_not_equal_to<B>::value; // error: ambiguous overload +`` + +* There is an issue when applying this trait to template classes. +If `operator!=` is defined but does not bind for a given template type, +it is still detected by the trait which returns `true` instead of `false`. +Example: +`` +#include <boost/type_traits/has_not_equal_to.hpp> +#include <iostream> + +template <class T> +struct contains { T data; }; + +template <class T> +bool operator!=(const contains<T> &lhs, const contains<T> &rhs) { + return f(lhs.data, rhs.data); +} + +class bad { }; +class good { }; +bool f(const good&, const good&) { } + +int main() { + std::cout<<std::boolalpha; + // works fine for contains<good> + std::cout<<boost::has_not_equal_to< contains< good > >::value<<'\n'; // true + contains<good> g; + g!=g; // ok + // does not work for contains<bad> + std::cout<<boost::has_not_equal_to< contains< bad > >::value<<'\n'; // true, should be false + contains<bad> b; + b!=b; // compile time error + return 0; +} +`` + +* `volatile` qualifier is not properly handled and would lead to undefined behavior + +[endsect] + diff --git a/libs/type_traits/doc/has_nothrow_assign.qbk b/libs/type_traits/doc/has_nothrow_assign.qbk new file mode 100644 index 0000000000..f71eb5c0c2 --- /dev/null +++ b/libs/type_traits/doc/has_nothrow_assign.qbk @@ -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] + diff --git a/libs/type_traits/doc/has_nothrow_constructor.qbk b/libs/type_traits/doc/has_nothrow_constructor.qbk new file mode 100644 index 0000000000..e8945cf367 --- /dev/null +++ b/libs/type_traits/doc/has_nothrow_constructor.qbk @@ -0,0 +1,36 @@ +[/ + 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 (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 2011) compilers more recent than Visual C++ 8, GCC-4.3, Greenhills 6.0, +Intel-11.0, and Codegear have the necessary compiler __intrinsics to ensure that this +trait "just works". You may also test to see if the necessary __intrinsics are available +by checking to see if the macro `BOOST_HAS_NOTHROW_CONSTRUCTOR` is defined. + +__header ` #include <boost/type_traits/has_nothrow_constructor.hpp>` or ` #include <boost/type_traits.hpp>` + +[endsect] + diff --git a/libs/type_traits/doc/has_nothrow_copy.qbk b/libs/type_traits/doc/has_nothrow_copy.qbk new file mode 100644 index 0000000000..c00a5a3a18 --- /dev/null +++ b/libs/type_traits/doc/has_nothrow_copy.qbk @@ -0,0 +1,36 @@ +[/ + 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 2011) compilers more recent than Visual C++ 8, GCC-4.3, Greenhills 6.0, +Intel-11.0, and Codegear have the necessary compiler __intrinsics to ensure that this +trait "just works". You may also test to see if the necessary __intrinsics are available +by checking to see if the macro `BOOST_HAS_NOTHROW_COPY` is defined. + +__header ` #include <boost/type_traits/has_nothrow_copy.hpp>` or ` #include <boost/type_traits.hpp>` + +[endsect] + diff --git a/libs/type_traits/doc/has_plus.qbk b/libs/type_traits/doc/has_plus.qbk new file mode 100644 index 0000000000..1dc790bd12 --- /dev/null +++ b/libs/type_traits/doc/has_plus.qbk @@ -0,0 +1,111 @@ +[/ + (C) Copyright 2009-2011 Frederic Bron. + 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_plus has_plus] + template <class Lhs, class Rhs=Lhs, class Ret=dont_care> + struct has_plus : public __tof {}; + +__inherit +If (i) `lhs` of type `Lhs` and `rhs` of type `Rhs` can be used in expression `lhs+rhs`, +and (ii) `Ret=dont_care` or the result of expression `lhs+rhs` is convertible to `Ret` +then inherits from __true_type, +otherwise inherits from __false_type. + +The default behaviour (`Ret=dont_care`) is to not check for the return value of binary `operator+`. +If `Ret` is different from the default `dont_care` type, the return value is checked to be convertible to `Ret`. +Convertible to `Ret` means that the return value of the operator can be used as argument to a function expecting `Ret`: +`` +void f(Ret); +Lhs lhs; +Rhs rhs; +f(lhs+rhs); // is valid if has_plus<Lhs, Rhs, Ret>::value==true +`` +If `Ret=void`, the return type is checked to be exactly `void`. + +__header `#include <boost/type_traits/has_plus.hpp>` or `#include <boost/type_traits/has_operator.hpp>` or `#include <boost/type_traits.hpp>` + +__examples + +[:`has_plus<Lhs, Rhs, Ret>::value_type` is the type `bool`.] +[:`has_plus<Lhs, Rhs, Ret>::value` is a `bool` integral constant expression.] +[:`has_plus<int>::value` is a `bool` integral constant expression that evaluates to `true`.] +[:`has_plus<long>` inherits from `__true_type`.] + +[:`has_plus<int, int, int>` inherits from `__true_type`.] +[:`has_plus<int, int, long>` inherits from `__true_type`.] +[:`has_plus<int, double, double>` inherits from `__true_type`.] +[:`has_plus<int, double, int>` inherits from `__true_type`.] +[:`has_plus<const int, int>::value` inherits from `__true_type`.] + +[:`has_plus<int, int, std::string>` inherits from `__false_type`.] + + +[*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits] + +[*Limitation:] + +* Requires a compiler with working SFINAE. + +[*Known issues:] + +* This trait cannot detect whether binary `operator+` is public or not: +if `operator+` is defined as a private member of `Lhs` then +instantiating `has_plus<Lhs>` will produce a compiler error. +For this reason `has_plus` cannot be used to determine whether a type has a public `operator+` or not. +`` +struct A { private: void operator+(const A&); }; +boost::has_plus<A>::value; // error: A::operator+(const A&) is private +`` + +* There is an issue if the operator exists only for type `A` and `B` is +convertible to `A`. In this case, the compiler will report an ambiguous overload. +`` +struct A { }; +void operator+(const A&, const A&); +struct B { operator A(); }; +boost::has_plus<A>::value; // this is fine +boost::has_plus<B>::value; // error: ambiguous overload +`` + +* There is an issue when applying this trait to template classes. +If `operator+` is defined but does not bind for a given template type, +it is still detected by the trait which returns `true` instead of `false`. +Example: +`` +#include <boost/type_traits/has_plus.hpp> +#include <iostream> + +template <class T> +struct contains { T data; }; + +template <class T> +bool operator+(const contains<T> &lhs, const contains<T> &rhs) { + return f(lhs.data, rhs.data); +} + +class bad { }; +class good { }; +bool f(const good&, const good&) { } + +int main() { + std::cout<<std::boolalpha; + // works fine for contains<good> + std::cout<<boost::has_plus< contains< good > >::value<<'\n'; // true + contains<good> g; + g+g; // ok + // does not work for contains<bad> + std::cout<<boost::has_plus< contains< bad > >::value<<'\n'; // true, should be false + contains<bad> b; + b+b; // compile time error + return 0; +} +`` + +* `volatile` qualifier is not properly handled and would lead to undefined behavior + +[endsect] + diff --git a/libs/type_traits/doc/has_plus_assign.qbk b/libs/type_traits/doc/has_plus_assign.qbk new file mode 100644 index 0000000000..be279e02fa --- /dev/null +++ b/libs/type_traits/doc/has_plus_assign.qbk @@ -0,0 +1,111 @@ +[/ + (C) Copyright 2009-2011 Frederic Bron. + 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_plus_assign has_plus_assign] + template <class Lhs, class Rhs=Lhs, class Ret=dont_care> + struct has_plus_assign : public __tof {}; + +__inherit +If (i) `lhs` of type `Lhs` and `rhs` of type `Rhs` can be used in expression `lhs+=rhs`, +and (ii) `Ret=dont_care` or the result of expression `lhs+=rhs` is convertible to `Ret` +then inherits from __true_type, +otherwise inherits from __false_type. + +The default behaviour (`Ret=dont_care`) is to not check for the return value of binary `operator+=`. +If `Ret` is different from the default `dont_care` type, the return value is checked to be convertible to `Ret`. +Convertible to `Ret` means that the return value of the operator can be used as argument to a function expecting `Ret`: +`` +void f(Ret); +Lhs lhs; +Rhs rhs; +f(lhs+=rhs); // is valid if has_plus_assign<Lhs, Rhs, Ret>::value==true +`` +If `Ret=void`, the return type is checked to be exactly `void`. + +__header `#include <boost/type_traits/has_plus_assign.hpp>` or `#include <boost/type_traits/has_operator.hpp>` or `#include <boost/type_traits.hpp>` + +__examples + +[:`has_plus_assign<Lhs, Rhs, Ret>::value_type` is the type `bool`.] +[:`has_plus_assign<Lhs, Rhs, Ret>::value` is a `bool` integral constant expression.] +[:`has_plus_assign<int>::value` is a `bool` integral constant expression that evaluates to `true`.] +[:`has_plus_assign<long>` inherits from `__true_type`.] + +[:`has_plus_assign<int, int, int>` inherits from `__true_type`.] +[:`has_plus_assign<int, int, long>` inherits from `__true_type`.] +[:`has_plus_assign<int, double, double>` inherits from `__true_type`.] +[:`has_plus_assign<int, double, int>` inherits from `__true_type`.] + +[:`has_plus_assign<const int, int>::value` inherits from `__false_type`.] +[:`has_plus_assign<int, int, std::string>` inherits from `__false_type`.] + + +[*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits] + +[*Limitation:] + +* Requires a compiler with working SFINAE. + +[*Known issues:] + +* This trait cannot detect whether binary `operator+=` is public or not: +if `operator+=` is defined as a private member of `Lhs` then +instantiating `has_plus_assign<Lhs>` will produce a compiler error. +For this reason `has_plus_assign` cannot be used to determine whether a type has a public `operator+=` or not. +`` +struct A { private: void operator+=(const A&); }; +boost::has_plus_assign<A>::value; // error: A::operator+=(const A&) is private +`` + +* There is an issue if the operator exists only for type `A` and `B` is +convertible to `A`. In this case, the compiler will report an ambiguous overload. +`` +struct A { }; +void operator+=(const A&, const A&); +struct B { operator A(); }; +boost::has_plus_assign<A>::value; // this is fine +boost::has_plus_assign<B>::value; // error: ambiguous overload +`` + +* There is an issue when applying this trait to template classes. +If `operator+=` is defined but does not bind for a given template type, +it is still detected by the trait which returns `true` instead of `false`. +Example: +`` +#include <boost/type_traits/has_plus_assign.hpp> +#include <iostream> + +template <class T> +struct contains { T data; }; + +template <class T> +bool operator+=(const contains<T> &lhs, const contains<T> &rhs) { + return f(lhs.data, rhs.data); +} + +class bad { }; +class good { }; +bool f(const good&, const good&) { } + +int main() { + std::cout<<std::boolalpha; + // works fine for contains<good> + std::cout<<boost::has_plus_assign< contains< good > >::value<<'\n'; // true + contains<good> g; + g+=g; // ok + // does not work for contains<bad> + std::cout<<boost::has_plus_assign< contains< bad > >::value<<'\n'; // true, should be false + contains<bad> b; + b+=b; // compile time error + return 0; +} +`` + +* `volatile` qualifier is not properly handled and would lead to undefined behavior + +[endsect] + diff --git a/libs/type_traits/doc/has_post_decrement.qbk b/libs/type_traits/doc/has_post_decrement.qbk new file mode 100644 index 0000000000..a3e87809e6 --- /dev/null +++ b/libs/type_traits/doc/has_post_decrement.qbk @@ -0,0 +1,112 @@ +[/ + (C) Copyright 2009-2011 Frederic Bron. + 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_post_decrement has_post_decrement] + template <class Lhs, class Ret=dont_care> + struct has_post_decrement : public __tof {}; + +__inherit +If (i) `lhs` of type `Lhs` can be used in expression `lhs--`, +and (ii) `Ret=dont_care` or the result of expression `lhs--` is convertible to `Ret` +then inherits from __true_type, +otherwise inherits from __false_type. + +The default behaviour (`Ret=dont_care`) is to not check for the return value of postfix `operator--`. +If `Ret` is different from the default `dont_care` type, the return value is checked to be convertible to `Ret`. +Convertible to `Ret` means that the return value of the operator can be used as argument to a function expecting `Ret`: +`` +void f(Ret); +Lhs lhs; +f(lhs--); // is valid if has_post_decrement<Lhs, Ret>::value==true +`` +If `Ret=void`, the return type is checked to be exactly `void`. + +__header `#include <boost/type_traits/has_post_decrement.hpp>` or `#include <boost/type_traits/has_operator.hpp>` or `#include <boost/type_traits.hpp>` + +__examples + +[:`has_post_decrement<Lhs, Ret>::value_type` is the type `bool`.] +[:`has_post_decrement<Lhs, Ret>::value` is a `bool` integral constant expression.] +[:`has_post_decrement<int>::value` is a `bool` integral constant expression that evaluates to `true`.] +[:`has_post_decrement<long>` inherits from `__true_type`.] + +[:`has_post_decrement<int, int>` inherits from `__true_type`.] +[:`has_post_decrement<int, long>` inherits from `__true_type`.] +[:`has_post_decrement<double, double>` inherits from `__true_type`.] +[:`has_post_decrement<double, int>` inherits from `__true_type`.] + +[:`has_post_decrement<bool>` inherits from `__false_type`.] +[:`has_post_decrement<const int>` inherits from `__false_type`.] +[:`has_post_decrement<void*>` inherits from `__false_type`.] +[:`has_post_decrement<int, std::string>` inherits from `__false_type`.] + + +[*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits] + +[*Limitation:] + +* Requires a compiler with working SFINAE. + +[*Known issues:] + +* This trait cannot detect whether postfix `operator--` is public or not: +if `operator--` is defined as a private member of `Lhs` then +instantiating `has_post_decrement<Lhs>` will produce a compiler error. +For this reason `has_post_decrement` cannot be used to determine whether a type has a public `operator--` or not. +`` +struct A { private: void operator--(int); }; +boost::has_post_decrement<A>::value; // error: A::operator--(int) is private +`` + +* There is an issue if the operator exists only for type `A` and `B` is +convertible to `A`. In this case, the compiler will report an ambiguous overload. +`` +struct A { }; +void operator--(const A&, int); +struct B { operator A(); }; +boost::has_post_decrement<A>::value; // this is fine +boost::has_post_decrement<B>::value; // error: ambiguous overload +`` + +* There is an issue when applying this trait to template classes. +If `operator--` is defined but does not bind for a given template type, +it is still detected by the trait which returns `true` instead of `false`. +Example: +`` +#include <boost/type_traits/has_post_decrement.hpp> +#include <iostream> + +template <class T> +struct contains { T data; }; + +template <class T> +bool operator--(const contains<T> &lhs, int) { + return f(lhs.data); +} + +class bad { }; +class good { }; +bool f(const good&, const good&) { } + +int main() { + std::cout<<std::boolalpha; + // works fine for contains<good> + std::cout<<boost::has_post_decrement< contains< good > >::value<<'\n'; // true + contains<good> g; + g--; // ok + // does not work for contains<bad> + std::cout<<boost::has_post_decrement< contains< bad > >::value<<'\n'; // true, should be false + contains<bad> b; + b--; // compile time error + return 0; +} +`` + +* `volatile` qualifier is not properly handled and would lead to undefined behavior + +[endsect] + diff --git a/libs/type_traits/doc/has_post_increment.qbk b/libs/type_traits/doc/has_post_increment.qbk new file mode 100644 index 0000000000..ddd93ebbca --- /dev/null +++ b/libs/type_traits/doc/has_post_increment.qbk @@ -0,0 +1,112 @@ +[/ + (C) Copyright 2009-2011 Frederic Bron. + 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_post_increment has_post_increment] + template <class Lhs, class Ret=dont_care> + struct has_post_increment : public __tof {}; + +__inherit +If (i) `lhs` of type `Lhs` can be used in expression `lhs++`, +and (ii) `Ret=dont_care` or the result of expression `lhs++` is convertible to `Ret` +then inherits from __true_type, +otherwise inherits from __false_type. + +The default behaviour (`Ret=dont_care`) is to not check for the return value of postfix `operator++`. +If `Ret` is different from the default `dont_care` type, the return value is checked to be convertible to `Ret`. +Convertible to `Ret` means that the return value of the operator can be used as argument to a function expecting `Ret`: +`` +void f(Ret); +Lhs lhs; +f(lhs++); // is valid if has_post_increment<Lhs, Ret>::value==true +`` +If `Ret=void`, the return type is checked to be exactly `void`. + +__header `#include <boost/type_traits/has_post_increment.hpp>` or `#include <boost/type_traits/has_operator.hpp>` or `#include <boost/type_traits.hpp>` + +__examples + +[:`has_post_increment<Lhs, Ret>::value_type` is the type `bool`.] +[:`has_post_increment<Lhs, Ret>::value` is a `bool` integral constant expression.] +[:`has_post_increment<int>::value` is a `bool` integral constant expression that evaluates to `true`.] +[:`has_post_increment<long>` inherits from `__true_type`.] + +[:`has_post_increment<int, int>` inherits from `__true_type`.] +[:`has_post_increment<int, long>` inherits from `__true_type`.] +[:`has_post_increment<double, double>` inherits from `__true_type`.] +[:`has_post_increment<double, int>` inherits from `__true_type`.] +[:`has_post_increment<bool>` inherits from `__true_type`.] + +[:`has_post_increment<const int>` inherits from `__false_type`.] +[:`has_post_increment<void*>` inherits from `__false_type`.] +[:`has_post_increment<int, std::string>` inherits from `__false_type`.] + + +[*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits] + +[*Limitation:] + +* Requires a compiler with working SFINAE. + +[*Known issues:] + +* This trait cannot detect whether postfix `operator++` is public or not: +if `operator++` is defined as a private member of `Lhs` then +instantiating `has_post_increment<Lhs>` will produce a compiler error. +For this reason `has_post_increment` cannot be used to determine whether a type has a public `operator++` or not. +`` +struct A { private: void operator++(int); }; +boost::has_post_increment<A>::value; // error: A::operator++(int) is private +`` + +* There is an issue if the operator exists only for type `A` and `B` is +convertible to `A`. In this case, the compiler will report an ambiguous overload. +`` +struct A { }; +void operator++(const A&, int); +struct B { operator A(); }; +boost::has_post_increment<A>::value; // this is fine +boost::has_post_increment<B>::value; // error: ambiguous overload +`` + +* There is an issue when applying this trait to template classes. +If `operator++` is defined but does not bind for a given template type, +it is still detected by the trait which returns `true` instead of `false`. +Example: +`` +#include <boost/type_traits/has_post_increment.hpp> +#include <iostream> + +template <class T> +struct contains { T data; }; + +template <class T> +bool operator++(const contains<T> &lhs, int) { + return f(lhs.data); +} + +class bad { }; +class good { }; +bool f(const good&, const good&) { } + +int main() { + std::cout<<std::boolalpha; + // works fine for contains<good> + std::cout<<boost::has_post_increment< contains< good > >::value<<'\n'; // true + contains<good> g; + g++; // ok + // does not work for contains<bad> + std::cout<<boost::has_post_increment< contains< bad > >::value<<'\n'; // true, should be false + contains<bad> b; + b++; // compile time error + return 0; +} +`` + +* `volatile` qualifier is not properly handled and would lead to undefined behavior + +[endsect] + diff --git a/libs/type_traits/doc/has_pre_decrement.qbk b/libs/type_traits/doc/has_pre_decrement.qbk new file mode 100644 index 0000000000..5393d71751 --- /dev/null +++ b/libs/type_traits/doc/has_pre_decrement.qbk @@ -0,0 +1,112 @@ +[/ + (C) Copyright 2009-2011 Frederic Bron. + 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_pre_decrement has_pre_decrement] + template <class Rhs, class Ret=dont_care> + struct has_pre_decrement : public __tof {}; + +__inherit +If (i) `rhs` of type `Rhs` can be used in expression `--rhs`, +and (ii) `Ret=dont_care` or the result of expression `--rhs` is convertible to `Ret` +then inherits from __true_type, +otherwise inherits from __false_type. + +The default behaviour (`Ret=dont_care`) is to not check for the return value of prefix `operator--`. +If `Ret` is different from the default `dont_care` type, the return value is checked to be convertible to `Ret`. +Convertible to `Ret` means that the return value of the operator can be used as argument to a function expecting `Ret`: +`` +void f(Ret); +Rhs rhs; +f(--rhs); // is valid if has_pre_decrement<Rhs, Ret>::value==true +`` +If `Ret=void`, the return type is checked to be exactly `void`. + +__header `#include <boost/type_traits/has_pre_decrement.hpp>` or `#include <boost/type_traits/has_operator.hpp>` or `#include <boost/type_traits.hpp>` + +__examples + +[:`has_pre_decrement<Rhs, Ret>::value_type` is the type `bool`.] +[:`has_pre_decrement<Rhs, Ret>::value` is a `bool` integral constant expression.] +[:`has_pre_decrement<int>::value` is a `bool` integral constant expression that evaluates to `true`.] +[:`has_pre_decrement<long>` inherits from `__true_type`.] + +[:`has_pre_decrement<int, int>` inherits from `__true_type`.] +[:`has_pre_decrement<int, long>` inherits from `__true_type`.] +[:`has_pre_decrement<double, double>` inherits from `__true_type`.] +[:`has_pre_decrement<double, int>` inherits from `__true_type`.] + +[:`has_pre_decrement<bool>` inherits from `__false_type`.] +[:`has_pre_decrement<const int>` inherits from `__false_type`.] +[:`has_pre_decrement<void*>` inherits from `__false_type`.] +[:`has_pre_decrement<int, std::string>` inherits from `__false_type`.] + + +[*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits] + +[*Limitation:] + +* Requires a compiler with working SFINAE. + +[*Known issues:] + +* This trait cannot detect whether prefix `operator--` is public or not: +if `operator--` is defined as a private member of `Rhs` then +instantiating `has_pre_decrement<Rhs>` will produce a compiler error. +For this reason `has_pre_decrement` cannot be used to determine whether a type has a public `operator--` or not. +`` +struct A { private: void operator--(); }; +boost::has_pre_decrement<A>::value; // error: A::operator--() is private +`` + +* There is an issue if the operator exists only for type `A` and `B` is +convertible to `A`. In this case, the compiler will report an ambiguous overload. +`` +struct A { }; +void operator--(const A&); +struct B { operator A(); }; +boost::has_pre_decrement<A>::value; // this is fine +boost::has_pre_decrement<B>::value; // error: ambiguous overload +`` + +* There is an issue when applying this trait to template classes. +If `operator--` is defined but does not bind for a given template type, +it is still detected by the trait which returns `true` instead of `false`. +Example: +`` +#include <boost/type_traits/has_pre_decrement.hpp> +#include <iostream> + +template <class T> +struct contains { T data; }; + +template <class T> +bool operator--(const contains<T> &rhs) { + return f(rhs.data); +} + +class bad { }; +class good { }; +bool f(const good&) { } + +int main() { + std::cout<<std::boolalpha; + // works fine for contains<good> + std::cout<<boost::has_pre_decrement< contains< good > >::value<<'\n'; // true + contains<good> g; + --g; // ok + // does not work for contains<bad> + std::cout<<boost::has_pre_decrement< contains< bad > >::value<<'\n'; // true, should be false + contains<bad> b; + --b; // compile time error + return 0; +} +`` + +* `volatile` qualifier is not properly handled and would lead to undefined behavior + +[endsect] + diff --git a/libs/type_traits/doc/has_pre_increment.qbk b/libs/type_traits/doc/has_pre_increment.qbk new file mode 100644 index 0000000000..74ef843eba --- /dev/null +++ b/libs/type_traits/doc/has_pre_increment.qbk @@ -0,0 +1,112 @@ +[/ + (C) Copyright 2009-2011 Frederic Bron. + 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_pre_increment has_pre_increment] + template <class Rhs, class Ret=dont_care> + struct has_pre_increment : public __tof {}; + +__inherit +If (i) `rhs` of type `Rhs` can be used in expression `++rhs`, +and (ii) `Ret=dont_care` or the result of expression `++rhs` is convertible to `Ret` +then inherits from __true_type, +otherwise inherits from __false_type. + +The default behaviour (`Ret=dont_care`) is to not check for the return value of prefix `operator++`. +If `Ret` is different from the default `dont_care` type, the return value is checked to be convertible to `Ret`. +Convertible to `Ret` means that the return value of the operator can be used as argument to a function expecting `Ret`: +`` +void f(Ret); +Rhs rhs; +f(++rhs); // is valid if has_pre_increment<Rhs, Ret>::value==true +`` +If `Ret=void`, the return type is checked to be exactly `void`. + +__header `#include <boost/type_traits/has_pre_increment.hpp>` or `#include <boost/type_traits/has_operator.hpp>` or `#include <boost/type_traits.hpp>` + +__examples + +[:`has_pre_increment<Rhs, Ret>::value_type` is the type `bool`.] +[:`has_pre_increment<Rhs, Ret>::value` is a `bool` integral constant expression.] +[:`has_pre_increment<int>::value` is a `bool` integral constant expression that evaluates to `true`.] +[:`has_pre_increment<long>` inherits from `__true_type`.] + +[:`has_pre_increment<int, int>` inherits from `__true_type`.] +[:`has_pre_increment<int, long>` inherits from `__true_type`.] +[:`has_pre_increment<double, double>` inherits from `__true_type`.] +[:`has_pre_increment<double, int>` inherits from `__true_type`.] +[:`has_pre_increment<bool>` inherits from `__true_type`.] + +[:`has_pre_increment<const int>` inherits from `__false_type`.] +[:`has_pre_increment<void*>` inherits from `__false_type`.] +[:`has_pre_increment<int, std::string>` inherits from `__false_type`.] + + +[*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits] + +[*Limitation:] + +* Requires a compiler with working SFINAE. + +[*Known issues:] + +* This trait cannot detect whether prefix `operator++` is public or not: +if `operator++` is defined as a private member of `Rhs` then +instantiating `has_pre_increment<Rhs>` will produce a compiler error. +For this reason `has_pre_increment` cannot be used to determine whether a type has a public `operator++` or not. +`` +struct A { private: void operator++(); }; +boost::has_pre_increment<A>::value; // error: A::operator++() is private +`` + +* There is an issue if the operator exists only for type `A` and `B` is +convertible to `A`. In this case, the compiler will report an ambiguous overload. +`` +struct A { }; +void operator++(const A&); +struct B { operator A(); }; +boost::has_pre_increment<A>::value; // this is fine +boost::has_pre_increment<B>::value; // error: ambiguous overload +`` + +* There is an issue when applying this trait to template classes. +If `operator++` is defined but does not bind for a given template type, +it is still detected by the trait which returns `true` instead of `false`. +Example: +`` +#include <boost/type_traits/has_pre_increment.hpp> +#include <iostream> + +template <class T> +struct contains { T data; }; + +template <class T> +bool operator++(const contains<T> &rhs) { + return f(rhs.data); +} + +class bad { }; +class good { }; +bool f(const good&) { } + +int main() { + std::cout<<std::boolalpha; + // works fine for contains<good> + std::cout<<boost::has_pre_increment< contains< good > >::value<<'\n'; // true + contains<good> g; + ++g; // ok + // does not work for contains<bad> + std::cout<<boost::has_pre_increment< contains< bad > >::value<<'\n'; // true, should be false + contains<bad> b; + ++b; // compile time error + return 0; +} +`` + +* `volatile` qualifier is not properly handled and would lead to undefined behavior + +[endsect] + diff --git a/libs/type_traits/doc/has_right_shift.qbk b/libs/type_traits/doc/has_right_shift.qbk new file mode 100644 index 0000000000..7c342ff13e --- /dev/null +++ b/libs/type_traits/doc/has_right_shift.qbk @@ -0,0 +1,112 @@ +[/ + (C) Copyright 2009-2011 Frederic Bron. + 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_right_shift has_right_shift] + template <class Lhs, class Rhs=Lhs, class Ret=dont_care> + struct has_right_shift : public __tof {}; + +__inherit +If (i) `lhs` of type `Lhs` and `rhs` of type `Rhs` can be used in expression `lhs>>rhs`, +and (ii) `Ret=dont_care` or the result of expression `lhs>>rhs` is convertible to `Ret` +then inherits from __true_type, +otherwise inherits from __false_type. + +The default behaviour (`Ret=dont_care`) is to not check for the return value of binary `operator>>`. +If `Ret` is different from the default `dont_care` type, the return value is checked to be convertible to `Ret`. +Convertible to `Ret` means that the return value of the operator can be used as argument to a function expecting `Ret`: +`` +void f(Ret); +Lhs lhs; +Rhs rhs; +f(lhs>>rhs); // is valid if has_right_shift<Lhs, Rhs, Ret>::value==true +`` +If `Ret=void`, the return type is checked to be exactly `void`. + +__header `#include <boost/type_traits/has_right_shift.hpp>` or `#include <boost/type_traits/has_operator.hpp>` or `#include <boost/type_traits.hpp>` + +__examples + +[:`has_right_shift<Lhs, Rhs, Ret>::value_type` is the type `bool`.] +[:`has_right_shift<Lhs, Rhs, Ret>::value` is a `bool` integral constant expression.] +[:`has_right_shift<int>::value` is a `bool` integral constant expression that evaluates to `true`.] +[:`has_right_shift<long>` inherits from `__true_type`.] + +[:`has_right_shift<int, int, int>` inherits from `__true_type`.] +[:`has_right_shift<const int, int>` inherits from `__true_type`.] +[:`has_right_shift<std::istream, int&>` inherits from `__true_type`.] +[:`has_right_shift<std::istream, char*, std::ostream>` inherits from `__true_type`.] +[:`has_right_shift<std::istream, std::string&>` inherits from `__true_type`.] + +[:`has_right_shift<int, double, bool>` inherits from `__false_type`.] +[:`has_right_shift<int, int, std::string>` inherits from `__false_type`.] + + +[*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits] + +[*Limitation:] + +* Requires a compiler with working SFINAE. + +[*Known issues:] + +* This trait cannot detect whether binary `operator>>` is public or not: +if `operator>>` is defined as a private member of `Lhs` then +instantiating `has_right_shift<Lhs>` will produce a compiler error. +For this reason `has_right_shift` cannot be used to determine whether a type has a public `operator>>` or not. +`` +struct A { private: void operator>>(const A&); }; +boost::has_right_shift<A>::value; // error: A::operator>>(const A&) is private +`` + +* There is an issue if the operator exists only for type `A` and `B` is +convertible to `A`. In this case, the compiler will report an ambiguous overload. +`` +struct A { }; +void operator>>(const A&, const A&); +struct B { operator A(); }; +boost::has_right_shift<A>::value; // this is fine +boost::has_right_shift<B>::value; // error: ambiguous overload +`` + +* There is an issue when applying this trait to template classes. +If `operator>>` is defined but does not bind for a given template type, +it is still detected by the trait which returns `true` instead of `false`. +Example: +`` +#include <boost/type_traits/has_right_shift.hpp> +#include <iostream> + +template <class T> +struct contains { T data; }; + +template <class T> +bool operator>>(const contains<T> &lhs, const contains<T> &rhs) { + return f(lhs.data, rhs.data); +} + +class bad { }; +class good { }; +bool f(const good&, const good&) { } + +int main() { + std::cout<<std::boolalpha; + // works fine for contains<good> + std::cout<<boost::has_right_shift< contains< good > >::value<<'\n'; // true + contains<good> g; + g>>g; // ok + // does not work for contains<bad> + std::cout<<boost::has_right_shift< contains< bad > >::value<<'\n'; // true, should be false + contains<bad> b; + b>>b; // compile time error + return 0; +} +`` + +* `volatile` qualifier is not properly handled and would lead to undefined behavior + +[endsect] + diff --git a/libs/type_traits/doc/has_right_shift_assign.qbk b/libs/type_traits/doc/has_right_shift_assign.qbk new file mode 100644 index 0000000000..4538d201b2 --- /dev/null +++ b/libs/type_traits/doc/has_right_shift_assign.qbk @@ -0,0 +1,109 @@ +[/ + (C) Copyright 2009-2011 Frederic Bron. + 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_right_shift_assign has_right_shift_assign] + template <class Lhs, class Rhs=Lhs, class Ret=dont_care> + struct has_right_shift_assign : public __tof {}; + +__inherit +If (i) `lhs` of type `Lhs` and `rhs` of type `Rhs` can be used in expression `lhs>>=rhs`, +and (ii) `Ret=dont_care` or the result of expression `lhs>>=rhs` is convertible to `Ret` +then inherits from __true_type, +otherwise inherits from __false_type. + +The default behaviour (`Ret=dont_care`) is to not check for the return value of binary `operator>>=`. +If `Ret` is different from the default `dont_care` type, the return value is checked to be convertible to `Ret`. +Convertible to `Ret` means that the return value of the operator can be used as argument to a function expecting `Ret`: +`` +void f(Ret); +Lhs lhs; +Rhs rhs; +f(lhs>>=rhs); // is valid if has_right_shift_assign<Lhs, Rhs, Ret>::value==true +`` +If `Ret=void`, the return type is checked to be exactly `void`. + +__header `#include <boost/type_traits/has_right_shift_assign.hpp>` or `#include <boost/type_traits/has_operator.hpp>` or `#include <boost/type_traits.hpp>` + +__examples + +[:`has_right_shift_assign<Lhs, Rhs, Ret>::value_type` is the type `bool`.] +[:`has_right_shift_assign<Lhs, Rhs, Ret>::value` is a `bool` integral constant expression.] +[:`has_right_shift_assign<int>::value` is a `bool` integral constant expression that evaluates to `true`.] +[:`has_right_shift_assign<long>` inherits from `__true_type`.] + +[:`has_right_shift_assign<int, int, int>` inherits from `__true_type`.] + +[:`has_right_shift_assign<const int, int>` inherits from `__false_type`.] +[:`has_right_shift_assign<int, double, bool>` inherits from `__false_type`.] +[:`has_right_shift_assign<int, int, std::string>` inherits from `__false_type`.] + + +[*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits] + +[*Limitation:] + +* Requires a compiler with working SFINAE. + +[*Known issues:] + +* This trait cannot detect whether binary `operator>>=` is public or not: +if `operator>>=` is defined as a private member of `Lhs` then +instantiating `has_right_shift_assign<Lhs>` will produce a compiler error. +For this reason `has_right_shift_assign` cannot be used to determine whether a type has a public `operator>>=` or not. +`` +struct A { private: void operator>>=(const A&); }; +boost::has_right_shift_assign<A>::value; // error: A::operator>>=(const A&) is private +`` + +* There is an issue if the operator exists only for type `A` and `B` is +convertible to `A`. In this case, the compiler will report an ambiguous overload. +`` +struct A { }; +void operator>>=(const A&, const A&); +struct B { operator A(); }; +boost::has_right_shift_assign<A>::value; // this is fine +boost::has_right_shift_assign<B>::value; // error: ambiguous overload +`` + +* There is an issue when applying this trait to template classes. +If `operator>>=` is defined but does not bind for a given template type, +it is still detected by the trait which returns `true` instead of `false`. +Example: +`` +#include <boost/type_traits/has_right_shift_assign.hpp> +#include <iostream> + +template <class T> +struct contains { T data; }; + +template <class T> +bool operator>>=(const contains<T> &lhs, const contains<T> &rhs) { + return f(lhs.data, rhs.data); +} + +class bad { }; +class good { }; +bool f(const good&, const good&) { } + +int main() { + std::cout<<std::boolalpha; + // works fine for contains<good> + std::cout<<boost::has_right_shift_assign< contains< good > >::value<<'\n'; // true + contains<good> g; + g>>=g; // ok + // does not work for contains<bad> + std::cout<<boost::has_right_shift_assign< contains< bad > >::value<<'\n'; // true, should be false + contains<bad> b; + b>>=b; // compile time error + return 0; +} +`` + +* `volatile` qualifier is not properly handled and would lead to undefined behavior + +[endsect] + diff --git a/libs/type_traits/doc/has_trivial_assign.qbk b/libs/type_traits/doc/has_trivial_assign.qbk new file mode 100644 index 0000000000..5ecfc0e1e3 --- /dev/null +++ b/libs/type_traits/doc/has_trivial_assign.qbk @@ -0,0 +1,50 @@ +[/ + 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 2011) compilers more recent than Visual C++ 8, GCC-4.3, Greenhills 6.0, +Intel-11.0, and Codegear have the necessary compiler __intrinsics to ensure that this +trait "just works". You may also test to see if the necessary __intrinsics are available +by checking to see if the macro `BOOST_HAS_TRIVIAL_ASSIGN` is defined. + + +__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] + diff --git a/libs/type_traits/doc/has_trivial_constructor.qbk b/libs/type_traits/doc/has_trivial_constructor.qbk new file mode 100644 index 0000000000..6bf7529a33 --- /dev/null +++ b/libs/type_traits/doc/has_trivial_constructor.qbk @@ -0,0 +1,58 @@ +[/ + 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 2011) compilers more recent than Visual C++ 8, GCC-4.3, Greenhills 6.0, +Intel-11.0, and Codegear have the necessary compiler __intrinsics to ensure that this +trait "just works". You may also test to see if the necessary __intrinsics are available +by checking to see if the macro `BOOST_HAS_TRIVIAL_CONSTRUCTOR` is defined. + + +__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] + diff --git a/libs/type_traits/doc/has_trivial_copy.qbk b/libs/type_traits/doc/has_trivial_copy.qbk new file mode 100644 index 0000000000..42019e4066 --- /dev/null +++ b/libs/type_traits/doc/has_trivial_copy.qbk @@ -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: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 2011) compilers more recent than Visual C++ 8, GCC-4.3, Greenhills 6.0, +Intel-11.0, and Codegear have the necessary compiler __intrinsics to ensure that this +trait "just works". You may also test to see if the necessary __intrinsics are available +by checking to see if the macro `BOOST_HAS_TRIVIAL_COPY` is defined. + + +__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] + diff --git a/libs/type_traits/doc/has_trivial_destructor.qbk b/libs/type_traits/doc/has_trivial_destructor.qbk new file mode 100644 index 0000000000..166c09251e --- /dev/null +++ b/libs/type_traits/doc/has_trivial_destructor.qbk @@ -0,0 +1,52 @@ +[/ + 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 2011) compilers more recent than Visual C++ 8, GCC-4.3, Greenhills 6.0, +Intel-11.0, and Codegear have the necessary compiler __intrinsics to ensure that this +trait "just works". You may also test to see if the necessary __intrinsics are available +by checking to see if the macro `BOOST_HAS_TRIVIAL_DESTRUCTOR` is defined. + + +__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] + diff --git a/libs/type_traits/doc/has_unary_minus.qbk b/libs/type_traits/doc/has_unary_minus.qbk new file mode 100644 index 0000000000..4758ba31ad --- /dev/null +++ b/libs/type_traits/doc/has_unary_minus.qbk @@ -0,0 +1,110 @@ +[/ + (C) Copyright 2009-2011 Frederic Bron. + 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_unary_minus has_unary_minus] + template <class Rhs, class Ret=dont_care> + struct has_unary_minus : public __tof {}; + +__inherit +If (i) `rhs` of type `Rhs` can be used in expression `-rhs`, +and (ii) `Ret=dont_care` or the result of expression `-rhs` is convertible to `Ret` +then inherits from __true_type, +otherwise inherits from __false_type. + +The default behaviour (`Ret=dont_care`) is to not check for the return value of prefix `operator-`. +If `Ret` is different from the default `dont_care` type, the return value is checked to be convertible to `Ret`. +Convertible to `Ret` means that the return value of the operator can be used as argument to a function expecting `Ret`: +`` +void f(Ret); +Rhs rhs; +f(-rhs); // is valid if has_unary_minus<Rhs, Ret>::value==true +`` +If `Ret=void`, the return type is checked to be exactly `void`. + +__header `#include <boost/type_traits/has_unary_minus.hpp>` or `#include <boost/type_traits/has_operator.hpp>` or `#include <boost/type_traits.hpp>` + +__examples + +[:`has_unary_minus<Rhs, Ret>::value_type` is the type `bool`.] +[:`has_unary_minus<Rhs, Ret>::value` is a `bool` integral constant expression.] +[:`has_unary_minus<int>::value` is a `bool` integral constant expression that evaluates to `true`.] +[:`has_unary_minus<long>` inherits from `__true_type`.] + +[:`has_unary_minus<int, int>` inherits from `__true_type`.] +[:`has_unary_minus<int, long>` inherits from `__true_type`.] +[:`has_unary_minus<double, double>` inherits from `__true_type`.] +[:`has_unary_minus<double, int>` inherits from `__true_type`.] +[:`has_unary_minus<const int>` inherits from `__true_type`.] + +[:`has_unary_minus<int, std::string>` inherits from `__false_type`.] + + +[*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits] + +[*Limitation:] + +* Requires a compiler with working SFINAE. + +[*Known issues:] + +* This trait cannot detect whether prefix `operator-` is public or not: +if `operator-` is defined as a private member of `Rhs` then +instantiating `has_unary_minus<Rhs>` will produce a compiler error. +For this reason `has_unary_minus` cannot be used to determine whether a type has a public `operator-` or not. +`` +struct A { private: void operator-(); }; +boost::has_unary_minus<A>::value; // error: A::operator-() is private +`` + +* There is an issue if the operator exists only for type `A` and `B` is +convertible to `A`. In this case, the compiler will report an ambiguous overload. +`` +struct A { }; +void operator-(const A&); +struct B { operator A(); }; +boost::has_unary_minus<A>::value; // this is fine +boost::has_unary_minus<B>::value; // error: ambiguous overload +`` + +* There is an issue when applying this trait to template classes. +If `operator-` is defined but does not bind for a given template type, +it is still detected by the trait which returns `true` instead of `false`. +Example: +`` +#include <boost/type_traits/has_unary_minus.hpp> +#include <iostream> + +template <class T> +struct contains { T data; }; + +template <class T> +bool operator-(const contains<T> &rhs) { + return f(rhs.data); +} + +class bad { }; +class good { }; +bool f(const good&) { } + +int main() { + std::cout<<std::boolalpha; + // works fine for contains<good> + std::cout<<boost::has_unary_minus< contains< good > >::value<<'\n'; // true + contains<good> g; + -g; // ok + // does not work for contains<bad> + std::cout<<boost::has_unary_minus< contains< bad > >::value<<'\n'; // true, should be false + contains<bad> b; + -b; // compile time error + return 0; +} +`` + +* `volatile` qualifier is not properly handled and would lead to undefined behavior + +[endsect] + diff --git a/libs/type_traits/doc/has_unary_plus.qbk b/libs/type_traits/doc/has_unary_plus.qbk new file mode 100644 index 0000000000..43540ec9e4 --- /dev/null +++ b/libs/type_traits/doc/has_unary_plus.qbk @@ -0,0 +1,110 @@ +[/ + (C) Copyright 2009-2011 Frederic Bron. + 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_unary_plus has_unary_plus] + template <class Rhs, class Ret=dont_care> + struct has_unary_plus : public __tof {}; + +__inherit +If (i) `rhs` of type `Rhs` can be used in expression `+rhs`, +and (ii) `Ret=dont_care` or the result of expression `+rhs` is convertible to `Ret` +then inherits from __true_type, +otherwise inherits from __false_type. + +The default behaviour (`Ret=dont_care`) is to not check for the return value of prefix `operator+`. +If `Ret` is different from the default `dont_care` type, the return value is checked to be convertible to `Ret`. +Convertible to `Ret` means that the return value of the operator can be used as argument to a function expecting `Ret`: +`` +void f(Ret); +Rhs rhs; +f(+rhs); // is valid if has_unary_plus<Rhs, Ret>::value==true +`` +If `Ret=void`, the return type is checked to be exactly `void`. + +__header `#include <boost/type_traits/has_unary_plus.hpp>` or `#include <boost/type_traits/has_operator.hpp>` or `#include <boost/type_traits.hpp>` + +__examples + +[:`has_unary_plus<Rhs, Ret>::value_type` is the type `bool`.] +[:`has_unary_plus<Rhs, Ret>::value` is a `bool` integral constant expression.] +[:`has_unary_plus<int>::value` is a `bool` integral constant expression that evaluates to `true`.] +[:`has_unary_plus<long>` inherits from `__true_type`.] + +[:`has_unary_plus<int, int>` inherits from `__true_type`.] +[:`has_unary_plus<int, long>` inherits from `__true_type`.] +[:`has_unary_plus<double, double>` inherits from `__true_type`.] +[:`has_unary_plus<double, int>` inherits from `__true_type`.] +[:`has_unary_plus<const int>` inherits from `__true_type`.] + +[:`has_unary_plus<int, std::string>` inherits from `__false_type`.] + + +[*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits] + +[*Limitation:] + +* Requires a compiler with working SFINAE. + +[*Known issues:] + +* This trait cannot detect whether prefix `operator+` is public or not: +if `operator+` is defined as a private member of `Rhs` then +instantiating `has_unary_plus<Rhs>` will produce a compiler error. +For this reason `has_unary_plus` cannot be used to determine whether a type has a public `operator+` or not. +`` +struct A { private: void operator+(); }; +boost::has_unary_plus<A>::value; // error: A::operator+() is private +`` + +* There is an issue if the operator exists only for type `A` and `B` is +convertible to `A`. In this case, the compiler will report an ambiguous overload. +`` +struct A { }; +void operator+(const A&); +struct B { operator A(); }; +boost::has_unary_plus<A>::value; // this is fine +boost::has_unary_plus<B>::value; // error: ambiguous overload +`` + +* There is an issue when applying this trait to template classes. +If `operator+` is defined but does not bind for a given template type, +it is still detected by the trait which returns `true` instead of `false`. +Example: +`` +#include <boost/type_traits/has_unary_plus.hpp> +#include <iostream> + +template <class T> +struct contains { T data; }; + +template <class T> +bool operator+(const contains<T> &rhs) { + return f(rhs.data); +} + +class bad { }; +class good { }; +bool f(const good&) { } + +int main() { + std::cout<<std::boolalpha; + // works fine for contains<good> + std::cout<<boost::has_unary_plus< contains< good > >::value<<'\n'; // true + contains<good> g; + +g; // ok + // does not work for contains<bad> + std::cout<<boost::has_unary_plus< contains< bad > >::value<<'\n'; // true, should be false + contains<bad> b; + +b; // compile time error + return 0; +} +`` + +* `volatile` qualifier is not properly handled and would lead to undefined behavior + +[endsect] + diff --git a/libs/type_traits/doc/has_virtual_destructor.qbk b/libs/type_traits/doc/has_virtual_destructor.qbk new file mode 100644 index 0000000000..5bc3e651b0 --- /dev/null +++ b/libs/type_traits/doc/has_virtual_destructor.qbk @@ -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: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 2011) compilers more recent than Visual C++ 8, GCC-4.3, Greenhills 6.0, +Intel-11.0, and Codegear have the necessary compiler __intrinsics to ensure that this +trait "just works". You may also test to see if the necessary __intrinsics are available +by checking to see if the macro `BOOST_HAS_VIRTUAL_DESTRUCTOR` is defined. + + +__std_ref 12.4. + +__header ` #include <boost/type_traits/has_virtual_destructor.hpp>` or ` #include <boost/type_traits.hpp>` + +[endsect] + diff --git a/libs/type_traits/doc/history.qbk b/libs/type_traits/doc/history.qbk new file mode 100644 index 0000000000..0cb2ce44a8 --- /dev/null +++ b/libs/type_traits/doc/history.qbk @@ -0,0 +1,35 @@ +[/ + Copyright 2009 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:history History] + +[h4 Boost 1.47.0] + +* [* Breaking change]: changed __is_convertible to C++0x behaviour when possible. +* Fixed issues [@https://svn.boost.org/trac/boost/ticket/5271 #5271], +[@https://svn.boost.org/trac/boost/ticket/4530 #4530]. + + +[h4 Boost 1.45.0] + +* Added new traits __add_rvalue_reference, __add_lvalue_reference and __common_type. +* Minor fixes to __is_signed, __is_unsigned and __is_virtual_base_of. + +[h4 Boost 1.44.0] + +* Added support for rvalue references throughout the library, plus two new traits classes +__is_rvalue_reference and __is_lvalue_reference. Fixes [@https://svn.boost.org/trac/boost/ticket/4407 #4407] +and [@https://svn.boost.org/trac/boost/ticket/3804 #3804]. +* Fixed ticket [@https://svn.boost.org/trac/boost/ticket/3621 #3621]. + +[h4 Boost 1.42.0] + +* Fixed issue [@https://svn.boost.org/trac/boost/ticket/3704 #3704]. + + +[endsect] + diff --git a/libs/type_traits/doc/html/boost_typetraits/background.html b/libs/type_traits/doc/html/boost_typetraits/background.html new file mode 100644 index 0000000000..2be4fa6fca --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/background.html @@ -0,0 +1,687 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>Background and Tutorial</title> +<link rel="stylesheet" href="../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="prev" href="intro.html" title="Introduction"> +<link rel="next" href="category.html" title="Type Traits by Category"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../boost.png"></td> +<td align="center"><a href="../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="intro.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="category.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h2 class="title" style="clear: both"> +<a name="boost_typetraits.background"></a><a class="link" href="background.html" title="Background and Tutorial">Background and Tutorial</a> +</h2></div></div></div> +<p> + 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 + <a href="http://www.ddj.com" target="_top">Dr Dobb's Journal</a>. + </p> +<p> + 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. + </p> +<p> + 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 <code class="computeroutput"><span class="identifier">strlen</span></code> and <code class="computeroutput"><span class="identifier">wcslen</span></code> + 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 <code class="computeroutput"><span class="keyword">char</span></code> and <code class="computeroutput"><span class="keyword">wchar_t</span></code> + into the class <code class="computeroutput"><span class="identifier">char_traits</span></code>. + Generic code that works with character strings can simply use <code class="computeroutput"><span class="identifier">char_traits</span><span class="special"><>::</span><span class="identifier">length</span></code> to determine the length of a null + terminated string, safe in the knowledge that specializations of <code class="computeroutput"><span class="identifier">char_traits</span></code> will use the most appropriate + method available to them. + </p> +<a name="boost_typetraits.background.type_traits"></a><h5> +<a name="boost_typetraits.background.type_traits-heading"></a> + <a class="link" href="background.html#boost_typetraits.background.type_traits">Type Traits</a> + </h5> +<p> + Class <code class="computeroutput"><span class="identifier">char_traits</span></code> is a classic + example of a collection of type specific properties wrapped up in a single + class - what Nathan Myers termed a <span class="emphasis"><em>baggage class</em></span><a class="link" href="background.html#background.references">[1]</a>. In the Boost type-traits library, + we<a class="link" href="background.html#background.references">[2]</a> 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 the type <a class="link" href="reference/integral_constant.html" title="integral_constant">true_type</a> + if the type has the specified property and inherits from <a class="link" href="reference/integral_constant.html" title="integral_constant">false_type</a> + 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. + </p> +<p> + 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 <code class="computeroutput"><span class="identifier">type</span></code> + that is the result of the transformation. All of the type-traits classes are + defined inside namespace <code class="computeroutput"><span class="identifier">boost</span></code>; + for brevity, namespace-qualification is omitted in most of the code samples + given. + </p> +<a name="boost_typetraits.background.implementation"></a><h5> +<a name="boost_typetraits.background.implementation-heading"></a> + <a class="link" href="background.html#boost_typetraits.background.implementation">Implementation</a> + </h5> +<p> + 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, + <code class="computeroutput"><span class="identifier">is_void</span><span class="special"><</span><span class="identifier">T</span><span class="special">></span></code> inherits + from <code class="computeroutput"><a class="link" href="reference/integral_constant.html" title="integral_constant">true_type</a></code> + only if <code class="computeroutput"><span class="identifier">T</span></code> is <code class="computeroutput"><span class="keyword">void</span></code>. + </p> +<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <a class="link" href="reference/is_void.html" title="is_void">is_void</a> <span class="special">:</span> <span class="keyword">public</span> <a class="link" href="reference/integral_constant.html" title="integral_constant">false_type</a><span class="special">{};</span> + +<span class="keyword">template</span> <span class="special"><></span> +<span class="keyword">struct</span> <a class="link" href="reference/is_void.html" title="is_void">is_void</a><span class="special"><</span><span class="keyword">void</span><span class="special">></span> <span class="special">:</span> <span class="keyword">public</span> <a class="link" href="reference/integral_constant.html" title="integral_constant">true_type</a><span class="special">{};</span> +</pre> +<p> + Here we define a primary version of the template class <code class="computeroutput"><a class="link" href="reference/is_void.html" title="is_void">is_void</a></code>, + and provide a full-specialization when <code class="computeroutput"><span class="identifier">T</span></code> + is <code class="computeroutput"><span class="keyword">void</span></code>. 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 <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">is_pointer</span><span class="special"><</span><span class="identifier">T</span><span class="special">></span></code>: + 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: + </p> +<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <a class="link" href="reference/is_pointer.html" title="is_pointer">is_pointer</a> <span class="special">:</span> <span class="keyword">public</span> <a class="link" href="reference/integral_constant.html" title="integral_constant">false_type</a><span class="special">{};</span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <a class="link" href="reference/is_pointer.html" title="is_pointer">is_pointer</a><span class="special"><</span><span class="identifier">T</span><span class="special">*></span> <span class="special">:</span> <span class="keyword">public</span> <a class="link" href="reference/integral_constant.html" title="integral_constant">true_type</a><span class="special">{};</span> +</pre> +<p> + 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: + </p> +<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">foo</span><span class="special">(</span><span class="identifier">T</span><span class="special">);</span> +<span class="keyword">void</span> <span class="identifier">foo</span><span class="special">(</span><span class="identifier">U</span><span class="special">);</span> +</pre> +<p> + Then you can also write a partial specialization of the form: + </p> +<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">class</span> <span class="identifier">c</span><span class="special">{</span> <span class="comment">/*details*/</span> <span class="special">};</span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">class</span> <span class="identifier">c</span><span class="special"><</span><span class="identifier">U</span><span class="special">>{</span> <span class="comment">/*details*/</span> <span class="special">};</span> +</pre> +<p> + 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. + </p> +<p> + As a more complex example of partial specialization consider the class <code class="computeroutput"><span class="identifier">remove_extent</span><span class="special"><</span><span class="identifier">T</span><span class="special">></span></code>. This + class defines a single typedef-member <code class="computeroutput"><span class="identifier">type</span></code> + 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: + </p> +<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <a class="link" href="reference/remove_extent.html" title="remove_extent">remove_extent</a> +<span class="special">{</span> <span class="keyword">typedef</span> <span class="identifier">T</span> <span class="identifier">type</span><span class="special">;</span> <span class="special">};</span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">N</span><span class="special">></span> +<span class="keyword">struct</span> <a class="link" href="reference/remove_extent.html" title="remove_extent">remove_extent</a><span class="special"><</span><span class="identifier">T</span><span class="special">[</span><span class="identifier">N</span><span class="special">]></span> +<span class="special">{</span> <span class="keyword">typedef</span> <span class="identifier">T</span> <span class="identifier">type</span><span class="special">;</span> <span class="special">};</span> +</pre> +<p> + The aim of <code class="computeroutput"><a class="link" href="reference/remove_extent.html" title="remove_extent">remove_extent</a></code> + is this: imagine a generic algorithm that is passed an array type as a template + parameter, <code class="computeroutput"><a class="link" href="reference/remove_extent.html" title="remove_extent">remove_extent</a></code> + provides a means of determining the underlying type of the array. For example + <code class="computeroutput"><span class="identifier">remove_extent</span><span class="special"><</span><span class="keyword">int</span><span class="special">[</span><span class="number">4</span><span class="special">][</span><span class="number">5</span><span class="special">]>::</span><span class="identifier">type</span></code> would evaluate to the type <code class="computeroutput"><span class="keyword">int</span><span class="special">[</span><span class="number">5</span><span class="special">]</span></code>. 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. + </p> +<a name="boost_typetraits.background.optimized_copy"></a><h5> +<a name="boost_typetraits.background.optimized_copy-heading"></a> + <a class="link" href="background.html#boost_typetraits.background.optimized_copy">Optimized copy</a> + </h5> +<p> + As an example of how the type traits classes can be used, consider the standard + library algorithm copy: + </p> +<pre class="programlisting"><span class="keyword">template</span><span class="special"><</span><span class="keyword">typename</span> <span class="identifier">Iter1</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">Iter2</span><span class="special">></span> +<span class="identifier">Iter2</span> <span class="identifier">copy</span><span class="special">(</span><span class="identifier">Iter1</span> <span class="identifier">first</span><span class="special">,</span> <span class="identifier">Iter1</span> <span class="identifier">last</span><span class="special">,</span> <span class="identifier">Iter2</span> <span class="identifier">out</span><span class="special">);</span> +</pre> +<p> + Obviously, there's no problem writing a generic version of copy that works + for all iterator types <code class="computeroutput"><span class="identifier">Iter1</span></code> + and <code class="computeroutput"><span class="identifier">Iter2</span></code>; however, there are + some circumstances when the copy operation can best be performed by a call + to <code class="computeroutput"><span class="identifier">memcpy</span></code>. In order to implement + copy in terms of <code class="computeroutput"><span class="identifier">memcpy</span></code> all + of the following conditions need to be met: + </p> +<div class="itemizedlist"><ul class="itemizedlist" type="disc"> +<li class="listitem"> + Both of the iterator types <code class="computeroutput"><span class="identifier">Iter1</span></code> + and <code class="computeroutput"><span class="identifier">Iter2</span></code> must be pointers. + </li> +<li class="listitem"> + Both <code class="computeroutput"><span class="identifier">Iter1</span></code> and <code class="computeroutput"><span class="identifier">Iter2</span></code> must point to the same type - excluding + const and volatile-qualifiers. + </li> +<li class="listitem"> + The type pointed to by <code class="computeroutput"><span class="identifier">Iter1</span></code> + must have a trivial assignment operator. + </li> +</ul></div> +<p> + By trivial assignment operator we mean that the type is either a scalar type<a class="link" href="background.html#background.references">[3]</a> or: + </p> +<div class="itemizedlist"><ul class="itemizedlist" type="disc"> +<li class="listitem"> + The type has no user defined assignment operator. + </li> +<li class="listitem"> + The type does not have any data members that are references. + </li> +<li class="listitem"> + All base classes, and all data member objects must have trivial assignment + operators. + </li> +</ul></div> +<p> + If all these conditions are met then a type can be copied using <code class="computeroutput"><span class="identifier">memcpy</span></code> rather than using a compiler generated + assignment operator. The type-traits library provides a class <code class="computeroutput"><a class="link" href="reference/has_trivial_assign.html" title="has_trivial_assign">has_trivial_assign</a></code>, + such that <code class="computeroutput"><span class="identifier">has_trivial_assign</span><span class="special"><</span><span class="identifier">T</span><span class="special">>::</span><span class="identifier">value</span></code> 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 <a class="link" href="reference/has_trivial_assign.html" title="has_trivial_assign">has_trivial_assign</a> + gives the wrong answer, it will give the "safe" wrong answer - that + trivial assignment is not allowable. + </p> +<p> + The code for an optimized version of copy that uses <code class="computeroutput"><span class="identifier">memcpy</span></code> + where appropriate is given in <a class="link" href="examples/copy.html" title="An Optimized Version of std::copy">the + examples</a>. The code begins by defining a template function <code class="computeroutput"><span class="identifier">do_copy</span></code> that performs a "slow but safe" + copy. The last parameter passed to this function may be either a <code class="computeroutput"><a class="link" href="reference/integral_constant.html" title="integral_constant">true_type</a></code> + or a <code class="computeroutput"><a class="link" href="reference/integral_constant.html" title="integral_constant">false_type</a></code>. + Following that there is an overload of do_copy that uses <code class="computeroutput"><span class="identifier">memcpy</span></code>: + this time the iterators are required to actually be pointers to the same type, + and the final parameter must be a <code class="computeroutput"><a class="link" href="reference/integral_constant.html" title="integral_constant">true_type</a></code>. + Finally, the version of <code class="computeroutput"><span class="identifier">copy</span></code> + calls <code class="computeroutput"><span class="identifier">do_copy</span></code>, passing <code class="computeroutput"><a class="link" href="reference/has_trivial_assign.html" title="has_trivial_assign">has_trivial_assign</a><span class="special"><</span><span class="identifier">value_type</span><span class="special">>()</span></code> as the final parameter: this will dispatch + to the optimized version where appropriate, otherwise it will call the "slow + but safe version". + </p> +<a name="boost_typetraits.background.was_it_worth_it_"></a><h5> +<a name="boost_typetraits.background.was_it_worth_it_-heading"></a> + <a class="link" href="background.html#boost_typetraits.background.was_it_worth_it_">Was it worth it?</a> + </h5> +<p> + It has often been repeated in these columns that "premature optimization + is the root of all evil" <a class="link" href="background.html#background.references">[4]</a>. + 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<a class="link" href="background.html#background.references">[5]</a> are shown in table + 1. + </p> +<p> + 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: + </p> +<div class="itemizedlist"><ul class="itemizedlist" type="disc"> +<li class="listitem"> + 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. + </li> +<li class="listitem"> + 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. + </li> +</ul></div> +<div class="table"> +<a name="boost_typetraits.background.time_taken_to_copy_1000_elements_using__copy_const_t___t_____times_in_micro_seconds_"></a><p class="title"><b>Table 1.1. Time taken to copy 1000 elements using `copy<const T*, T*>` (times + in micro-seconds)</b></p> +<div class="table-contents"><table class="table" summary="Time taken to copy 1000 elements using `copy<const T*, T*>` (times + in micro-seconds)"> +<colgroup> +<col> +<col> +<col> +</colgroup> +<thead><tr> +<th> + <p> + Version + </p> + </th> +<th> + <p> + T + </p> + </th> +<th> + <p> + Time + </p> + </th> +</tr></thead> +<tbody> +<tr> +<td> + <p> + "Optimized" copy + </p> + </td> +<td> + <p> + char + </p> + </td> +<td> + <p> + 0.99 + </p> + </td> +</tr> +<tr> +<td> + <p> + Conventional copy + </p> + </td> +<td> + <p> + char + </p> + </td> +<td> + <p> + 8.07 + </p> + </td> +</tr> +<tr> +<td> + <p> + "Optimized" copy + </p> + </td> +<td> + <p> + int + </p> + </td> +<td> + <p> + 2.52 + </p> + </td> +</tr> +<tr> +<td> + <p> + Conventional copy + </p> + </td> +<td> + <p> + int + </p> + </td> +<td> + <p> + 8.02 + </p> + </td> +</tr> +</tbody> +</table></div> +</div> +<br class="table-break"><a name="boost_typetraits.background.pair_of_references"></a><h5> +<a name="boost_typetraits.background.pair_of_references-heading"></a> + <a class="link" href="background.html#boost_typetraits.background.pair_of_references">Pair of References</a> + </h5> +<p> + 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 <a class="link" href="background.html#background.references">[6]</a>. + </p> +<p> + First, let us examine the definition of <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span></code>, omitting + the comparison operators, default constructor, and template copy constructor + for simplicity: + </p> +<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">typename</span> <span class="identifier">T1</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">T2</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">pair</span> +<span class="special">{</span> +<span class="keyword">typedef</span> <span class="identifier">T1</span> <span class="identifier">first_type</span><span class="special">;</span> +<span class="keyword">typedef</span> <span class="identifier">T2</span> <span class="identifier">second_type</span><span class="special">;</span> + +<span class="identifier">T1</span> <span class="identifier">first</span><span class="special">;</span> +<span class="identifier">T2</span> <span class="identifier">second</span><span class="special">;</span> + +<span class="identifier">pair</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">T1</span> <span class="special">&</span> <span class="identifier">nfirst</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">T2</span> <span class="special">&</span> <span class="identifier">nsecond</span><span class="special">)</span> +<span class="special">:</span><span class="identifier">first</span><span class="special">(</span><span class="identifier">nfirst</span><span class="special">),</span> <span class="identifier">second</span><span class="special">(</span><span class="identifier">nsecond</span><span class="special">)</span> <span class="special">{</span> <span class="special">}</span> +<span class="special">};</span> +</pre> +<p> + 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 <a class="link" href="background.html#background.references">[7]</a>. 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: + </p> +<div class="table"> +<a name="boost_typetraits.background.required_constructor_argument_types"></a><p class="title"><b>Table 1.2. Required Constructor Argument Types</b></p> +<div class="table-contents"><table class="table" summary="Required Constructor Argument Types"> +<colgroup> +<col> +<col> +</colgroup> +<thead><tr> +<th> + <p> + Type of <code class="computeroutput"><span class="identifier">T1</span></code> + </p> + </th> +<th> + <p> + Type of parameter to initializing constructor + </p> + </th> +</tr></thead> +<tbody> +<tr> +<td> + <p> + T + </p> + </td> +<td> + <p> + const T & + </p> + </td> +</tr> +<tr> +<td> + <p> + T & + </p> + </td> +<td> + <p> + T & + </p> + </td> +</tr> +<tr> +<td> + <p> + const T & + </p> + </td> +<td> + <p> + const T & + </p> + </td> +</tr> +</tbody> +</table></div> +</div> +<br class="table-break"><p> + 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 <a class="link" href="reference/add_reference.html" title="add_reference">add_reference</a>, which + adds a reference to its type, unless it is already a reference. + </p> +<div class="table"> +<a name="boost_typetraits.background.using_add_reference_to_synthesize_the_correct_constructor_type"></a><p class="title"><b>Table 1.3. Using add_reference to synthesize the correct constructor type</b></p> +<div class="table-contents"><table class="table" summary="Using add_reference to synthesize the correct constructor type"> +<colgroup> +<col> +<col> +<col> +</colgroup> +<thead><tr> +<th> + <p> + Type of <code class="computeroutput"><span class="identifier">T1</span></code> + </p> + </th> +<th> + <p> + Type of <code class="computeroutput"><span class="keyword">const</span> <span class="identifier">T1</span></code> + </p> + </th> +<th> + <p> + Type of <code class="computeroutput"><span class="identifier">add_reference</span><span class="special"><</span><span class="keyword">const</span> + <span class="identifier">T1</span><span class="special">>::</span><span class="identifier">type</span></code> + </p> + </th> +</tr></thead> +<tbody> +<tr> +<td> + <p> + T + </p> + </td> +<td> + <p> + const T + </p> + </td> +<td> + <p> + const T & + </p> + </td> +</tr> +<tr> +<td> + <p> + T & + </p> + </td> +<td> + <p> + T & [8] + </p> + </td> +<td> + <p> + T & + </p> + </td> +</tr> +<tr> +<td> + <p> + const T & + </p> + </td> +<td> + <p> + const T & + </p> + </td> +<td> + <p> + const T & + </p> + </td> +</tr> +</tbody> +</table></div> +</div> +<br class="table-break"><p> + This allows us to build a primary template definition for <code class="computeroutput"><span class="identifier">pair</span></code> + that can contain non-reference types, reference types, and constant reference + types: + </p> +<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">typename</span> <span class="identifier">T1</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">T2</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">pair</span> +<span class="special">{</span> +<span class="keyword">typedef</span> <span class="identifier">T1</span> <span class="identifier">first_type</span><span class="special">;</span> +<span class="keyword">typedef</span> <span class="identifier">T2</span> <span class="identifier">second_type</span><span class="special">;</span> + +<span class="identifier">T1</span> <span class="identifier">first</span><span class="special">;</span> +<span class="identifier">T2</span> <span class="identifier">second</span><span class="special">;</span> + +<span class="identifier">pair</span><span class="special">(</span><span class="identifier">boost</span><span class="special">::</span><a class="link" href="reference/add_reference.html" title="add_reference">add_reference</a><span class="special"><</span><span class="keyword">const</span> <span class="identifier">T1</span><span class="special">>::</span><span class="identifier">type</span> <span class="identifier">nfirst</span><span class="special">,</span> + <span class="identifier">boost</span><span class="special">::</span><a class="link" href="reference/add_reference.html" title="add_reference">add_reference</a><span class="special"><</span><span class="keyword">const</span> <span class="identifier">T2</span><span class="special">>::</span><span class="identifier">type</span> <span class="identifier">nsecond</span><span class="special">)</span> +<span class="special">:</span><span class="identifier">first</span><span class="special">(</span><span class="identifier">nfirst</span><span class="special">),</span> <span class="identifier">second</span><span class="special">(</span><span class="identifier">nsecond</span><span class="special">)</span> <span class="special">{</span> <span class="special">}</span> +<span class="special">};</span> +</pre> +<p> + Add back in the standard comparison operators, default constructor, and template + copy constructor (which are all the same), and you have a <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span></code> that + can hold reference types! + </p> +<p> + This same extension could have been done using partial template specialization + of <code class="computeroutput"><span class="identifier">pair</span></code>, but to specialize + <code class="computeroutput"><span class="identifier">pair</span></code> 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. + </p> +<a name="boost_typetraits.background.conclusion"></a><h5> +<a name="boost_typetraits.background.conclusion-heading"></a> + <a class="link" href="background.html#boost_typetraits.background.conclusion">Conclusion</a> + </h5> +<p> + 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. + </p> +<a name="boost_typetraits.background.acknowledgements"></a><h5> +<a name="boost_typetraits.background.acknowledgements-heading"></a> + <a class="link" href="background.html#boost_typetraits.background.acknowledgements">Acknowledgements</a> + </h5> +<p> + The authors would like to thank Beman Dawes and Howard Hinnant for their helpful + comments when preparing this article. + </p> +<a name="boost_typetraits.background._anchor_id__background_references___references"></a><h5> +<a name="boost_typetraits.background._anchor_id__background_references___references-heading"></a> + <a class="link" href="background.html#boost_typetraits.background._anchor_id__background_references___references"><a name="background.references"></a>References</a> + </h5> +<div class="orderedlist"><ol class="orderedlist" type="1"> +<li class="listitem"> + Nathan C. Myers, C++ Report, June 1995. + </li> +<li class="listitem"> + 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. + </li> +<li class="listitem"> + 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. + </li> +<li class="listitem"> + This quote is from Donald Knuth, ACM Computing Surveys, December 1974, + pg 268. + </li> +<li class="listitem"> + 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. + </li> +<li class="listitem"> + 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". + </li> +<li class="listitem"> + 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. + </li> +<li class="listitem"> + 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. + </li> +</ol></div> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="intro.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="category.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/category.html b/libs/type_traits/doc/html/boost_typetraits/category.html new file mode 100644 index 0000000000..f639f2fb10 --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/category.html @@ -0,0 +1,67 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>Type Traits by Category</title> +<link rel="stylesheet" href="../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="prev" href="background.html" title="Background and Tutorial"> +<link rel="next" href="category/value_traits.html" title="Type Traits that Describe the Properties of a Type"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../boost.png"></td> +<td align="center"><a href="../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="background.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="category/value_traits.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h2 class="title" style="clear: both"> +<a name="boost_typetraits.category"></a><a class="link" href="category.html" title="Type Traits by Category">Type Traits by Category</a> +</h2></div></div></div> +<div class="toc"><dl> +<dt><span class="section"><a href="category/value_traits.html">Type Traits that + Describe the Properties of a Type</a></span></dt> +<dd><dl> +<dt><span class="section"><a href="category/value_traits/primary.html">Categorizing + a Type</a></span></dt> +<dt><span class="section"><a href="category/value_traits/properties.html">General + Type Properties</a></span></dt> +<dt><span class="section"><a href="category/value_traits/relate.html">Relationships + Between Two Types</a></span></dt> +<dt><span class="section"><a href="category/value_traits/operators.html">Operator + Type Traits</a></span></dt> +</dl></dd> +<dt><span class="section"><a href="category/transform.html">Type Traits that + Transform One Type to Another</a></span></dt> +<dt><span class="section"><a href="category/alignment.html">Synthesizing Types + with Specific Alignments</a></span></dt> +<dt><span class="section"><a href="category/function.html">Decomposing Function + Types</a></span></dt> +</dl></div> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="background.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="category/value_traits.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/category/alignment.html b/libs/type_traits/doc/html/boost_typetraits/category/alignment.html new file mode 100644 index 0000000000..90d68e95e5 --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/category/alignment.html @@ -0,0 +1,63 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>Synthesizing Types with Specific Alignments</title> +<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../category.html" title="Type Traits by Category"> +<link rel="prev" href="transform.html" title="Type Traits that Transform One Type to Another"> +<link rel="next" href="function.html" title="Decomposing Function Types"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td> +<td align="center"><a href="../../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="transform.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../category.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="function.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h3 class="title"> +<a name="boost_typetraits.category.alignment"></a><a class="link" href="alignment.html" title="Synthesizing Types with Specific Alignments">Synthesizing Types + with Specific Alignments</a> +</h3></div></div></div> +<p> + Some low level memory management routines need to synthesize a POD type with + specific alignment properties. The template <code class="computeroutput"><a class="link" href="../reference/type_with_alignment.html" title="type_with_alignment">type_with_alignment</a></code> + finds the smallest type with a specified alignment, while template <code class="computeroutput"><a class="link" href="../reference/aligned_storage.html" title="aligned_storage">aligned_storage</a></code> + creates a type with a specific size and alignment. + </p> +<p> + <span class="bold"><strong>Synopsis</strong></span> + </p> +<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">Align</span><span class="special">></span> +<span class="keyword">struct</span> <a class="link" href="../reference/type_with_alignment.html" title="type_with_alignment">type_with_alignment</a><span class="special">;</span> + +<span class="keyword">template</span> <span class="special"><</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">Size</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">Align</span><span class="special">></span> +<span class="keyword">struct</span> <a class="link" href="../reference/aligned_storage.html" title="aligned_storage">aligned_storage</a><span class="special">;</span> +</pre> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="transform.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../category.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="function.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/category/function.html b/libs/type_traits/doc/html/boost_typetraits/category/function.html new file mode 100644 index 0000000000..3345d5241e --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/category/function.html @@ -0,0 +1,60 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>Decomposing Function Types</title> +<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../category.html" title="Type Traits by Category"> +<link rel="prev" href="alignment.html" title="Synthesizing Types with Specific Alignments"> +<link rel="next" href="../user_defined.html" title="User Defined Specializations"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td> +<td align="center"><a href="../../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="alignment.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../category.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="../user_defined.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h3 class="title"> +<a name="boost_typetraits.category.function"></a><a class="link" href="function.html" title="Decomposing Function Types">Decomposing Function + Types</a> +</h3></div></div></div> +<p> + The class template <a class="link" href="../reference/function_traits.html" title="function_traits">function_traits</a> + extracts information from function types (see also <a class="link" href="../reference/is_function.html" title="is_function">is_function</a>). + This traits class allows you to tell how many arguments a function takes, + what those argument types are, and what the return type is. + </p> +<p> + <span class="bold"><strong>Synopsis</strong></span> + </p> +<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">Align</span><span class="special">></span> +<span class="keyword">struct</span> <a class="link" href="../reference/function_traits.html" title="function_traits">function_traits</a><span class="special">;</span> +</pre> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="alignment.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../category.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="../user_defined.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/category/transform.html b/libs/type_traits/doc/html/boost_typetraits/category/transform.html new file mode 100644 index 0000000000..12694cf433 --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/category/transform.html @@ -0,0 +1,179 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>Type Traits that Transform One Type to Another</title> +<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../category.html" title="Type Traits by Category"> +<link rel="prev" href="value_traits/operators.html" title="Operator Type Traits"> +<link rel="next" href="alignment.html" title="Synthesizing Types with Specific Alignments"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td> +<td align="center"><a href="../../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="value_traits/operators.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../category.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="alignment.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h3 class="title"> +<a name="boost_typetraits.category.transform"></a><a class="link" href="transform.html" title="Type Traits that Transform One Type to Another">Type Traits that + Transform One Type to Another</a> +</h3></div></div></div> +<p> + The following templates transform one type to another, based upon some well-defined + rule. Each template has a single member called <code class="computeroutput"><span class="identifier">type</span></code> + that is the result of applying the transformation to the template argument + <code class="computeroutput"><span class="identifier">T</span></code>. + </p> +<p> + <span class="bold"><strong>Synopsis:</strong></span> + </p> +<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <a class="link" href="../reference/add_const.html" title="add_const">add_const</a><span class="special">;</span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <a class="link" href="../reference/add_cv.html" title="add_cv">add_cv</a><span class="special">;</span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <a class="link" href="../reference/add_lvalue_reference.html" title="add_lvalue_reference">add_lvalue_reference</a><span class="special">;</span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <a class="link" href="../reference/add_pointer.html" title="add_pointer">add_pointer</a><span class="special">;</span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <a class="link" href="../reference/add_reference.html" title="add_reference">add_reference</a><span class="special">;</span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <a class="link" href="../reference/add_rvalue_reference.html" title="add_rvalue_reference">add_rvalue_reference</a><span class="special">;</span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <a class="link" href="../reference/add_volatile.html" title="add_volatile">add_volatile</a><span class="special">;</span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">bool</span> <span class="identifier">B</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">U</span><span class="special">></span> +<span class="keyword">struct</span> <a class="link" href="../reference/conditional.html" title="conditional">conditional</a><span class="special">;</span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span><span class="special">...</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <a class="link" href="../reference/common_type.html" title="common_type">common_type</a><span class="special">;</span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <a class="link" href="../reference/decay.html" title="decay">decay</a><span class="special">;</span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <a class="link" href="../reference/floating_point_promotion.html" title="floating_point_promotion">floating_point_promotion</a><span class="special">;</span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <a class="link" href="../reference/integral_promotion.html" title="integral_promotion">integral_promotion</a><span class="special">;</span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <a class="link" href="../reference/make_signed.html" title="make_signed">make_signed</a><span class="special">;</span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <a class="link" href="../reference/make_unsigned.html" title="make_unsigned">make_unsigned</a><span class="special">;</span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <a class="link" href="../reference/promote.html" title="promote">promote</a><span class="special">;</span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <a class="link" href="../reference/remove_all_extents.html" title="remove_all_extents">remove_all_extents</a><span class="special">;</span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <a class="link" href="../reference/remove_const.html" title="remove_const">remove_const</a><span class="special">;</span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <a class="link" href="../reference/remove_cv.html" title="remove_cv">remove_cv</a><span class="special">;</span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <a class="link" href="../reference/remove_extent.html" title="remove_extent">remove_extent</a><span class="special">;</span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <a class="link" href="../reference/remove_pointer.html" title="remove_pointer">remove_pointer</a><span class="special">;</span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <a class="link" href="../reference/remove_reference.html" title="remove_reference">remove_reference</a><span class="special">;</span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <a class="link" href="../reference/remove_volatile.html" title="remove_volatile">remove_volatile</a><span class="special">;</span> +</pre> +<a name="boost_typetraits.category.transform.broken_compiler_workarounds_"></a><h5> +<a name="boost_typetraits.category.transform.broken_compiler_workarounds_-heading"></a> + <a class="link" href="transform.html#boost_typetraits.category.transform.broken_compiler_workarounds_">Broken + Compiler Workarounds:</a> + </h5> +<p> + 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. + </p> +<p> + 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. + </p> +<p> + The first part guarantees the successful compilation of something like this: + </p> +<pre class="programlisting"><span class="identifier">BOOST_STATIC_ASSERT</span><span class="special">((</span><span class="identifier">is_same</span><span class="special"><</span><span class="keyword">char</span><span class="special">,</span> <span class="identifier">remove_reference</span><span class="special"><</span><span class="keyword">char</span><span class="special">&>::</span><span class="identifier">type</span><span class="special">>::</span><span class="identifier">value</span><span class="special">));</span> +<span class="identifier">BOOST_STATIC_ASSERT</span><span class="special">((</span><span class="identifier">is_same</span><span class="special"><</span><span class="keyword">char</span> <span class="keyword">const</span><span class="special">,</span> <span class="identifier">remove_reference</span><span class="special"><</span><span class="keyword">char</span> <span class="keyword">const</span><span class="special">&>::</span><span class="identifier">type</span><span class="special">>::</span><span class="identifier">value</span><span class="special">));</span> +<span class="identifier">BOOST_STATIC_ASSERT</span><span class="special">((</span><span class="identifier">is_same</span><span class="special"><</span><span class="keyword">char</span> <span class="keyword">volatile</span><span class="special">,</span> <span class="identifier">remove_reference</span><span class="special"><</span><span class="keyword">char</span> <span class="keyword">volatile</span><span class="special">&>::</span><span class="identifier">type</span><span class="special">>::</span><span class="identifier">value</span><span class="special">));</span> +<span class="identifier">BOOST_STATIC_ASSERT</span><span class="special">((</span><span class="identifier">is_same</span><span class="special"><</span><span class="keyword">char</span> <span class="keyword">const</span> <span class="keyword">volatile</span><span class="special">,</span> <span class="identifier">remove_reference</span><span class="special"><</span><span class="keyword">char</span> <span class="keyword">const</span> <span class="keyword">volatile</span><span class="special">&>::</span><span class="identifier">type</span><span class="special">>::</span><span class="identifier">value</span><span class="special">));</span> +<span class="identifier">BOOST_STATIC_ASSERT</span><span class="special">((</span><span class="identifier">is_same</span><span class="special"><</span><span class="keyword">char</span><span class="special">*,</span> <span class="identifier">remove_reference</span><span class="special"><</span><span class="keyword">char</span><span class="special">*&>::</span><span class="identifier">type</span><span class="special">>::</span><span class="identifier">value</span><span class="special">));</span> +<span class="identifier">BOOST_STATIC_ASSERT</span><span class="special">((</span><span class="identifier">is_same</span><span class="special"><</span><span class="keyword">char</span> <span class="keyword">const</span><span class="special">*,</span> <span class="identifier">remove_reference</span><span class="special"><</span><span class="keyword">char</span> <span class="keyword">const</span><span class="special">*&>::</span><span class="identifier">type</span><span class="special">>::</span><span class="identifier">value</span><span class="special">));</span> +<span class="special">...</span> +<span class="identifier">BOOST_STATIC_ASSERT</span><span class="special">((</span><span class="identifier">is_same</span><span class="special"><</span><span class="keyword">char</span> <span class="keyword">const</span> <span class="keyword">volatile</span><span class="special">*</span> <span class="keyword">const</span> <span class="keyword">volatile</span><span class="special">*</span> <span class="keyword">const</span> <span class="keyword">volatile</span><span class="special">,</span> <span class="identifier">remove_reference</span><span class="special"><</span><span class="keyword">char</span> <span class="keyword">const</span> <span class="keyword">volatile</span><span class="special">*</span> <span class="keyword">const</span> <span class="keyword">volatile</span><span class="special">*</span> <span class="keyword">const</span> <span class="keyword">volatile</span><span class="special">&>::</span><span class="identifier">type</span><span class="special">>::</span><span class="identifier">value</span><span class="special">));</span> +</pre> +<p> + and the second part provides the library's users with a mechanism to make + the above code work not only for <code class="computeroutput"><span class="keyword">char</span></code>, + <code class="computeroutput"><span class="keyword">int</span></code> or other built-in type, + but for their own types as well: + </p> +<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">myspace</span><span class="special">{</span> + <span class="keyword">struct</span> <span class="identifier">MyClass</span> <span class="special">{};</span> +<span class="special">}</span> +<span class="comment">// declare this at global scope:</span> +<span class="identifier">BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION</span><span class="special">(</span><span class="identifier">myspace</span><span class="special">::</span><span class="identifier">MyClass</span><span class="special">)</span> +<span class="comment">// transformations on myspace::MyClass now work:</span> +<span class="identifier">BOOST_STATIC_ASSERT</span><span class="special">((</span><span class="identifier">is_same</span><span class="special"><</span><span class="identifier">myspace</span><span class="special">::</span><span class="identifier">MyClass</span><span class="special">,</span> <span class="identifier">remove_reference</span><span class="special"><</span><span class="identifier">myspace</span><span class="special">::</span><span class="identifier">MyClass</span><span class="special">&>::</span><span class="identifier">type</span><span class="special">>::</span><span class="identifier">value</span><span class="special">));</span> +<span class="identifier">BOOST_STATIC_ASSERT</span><span class="special">((</span><span class="identifier">is_same</span><span class="special"><</span><span class="identifier">myspace</span><span class="special">::</span><span class="identifier">MyClass</span><span class="special">,</span> <span class="identifier">remove_const</span><span class="special"><</span><span class="identifier">myspace</span><span class="special">::</span><span class="identifier">MyClass</span> <span class="keyword">const</span><span class="special">>::</span><span class="identifier">type</span><span class="special">>::</span><span class="identifier">value</span><span class="special">));</span> +<span class="comment">// etc.</span> +</pre> +<p> + Note that the macro BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION evaluates + to nothing on those compilers that <span class="bold"><strong>do</strong></span> support + partial specialization. + </p> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="value_traits/operators.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../category.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="alignment.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/category/value_traits.html b/libs/type_traits/doc/html/boost_typetraits/category/value_traits.html new file mode 100644 index 0000000000..f4567c423e --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/category/value_traits.html @@ -0,0 +1,68 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>Type Traits that Describe the Properties of a Type</title> +<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../category.html" title="Type Traits by Category"> +<link rel="prev" href="../category.html" title="Type Traits by Category"> +<link rel="next" href="value_traits/primary.html" title="Categorizing a Type"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td> +<td align="center"><a href="../../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="../category.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../category.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="value_traits/primary.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h3 class="title"> +<a name="boost_typetraits.category.value_traits"></a><a class="link" href="value_traits.html" title="Type Traits that Describe the Properties of a Type">Type Traits that + Describe the Properties of a Type</a> +</h3></div></div></div> +<div class="toc"><dl> +<dt><span class="section"><a href="value_traits/primary.html">Categorizing + a Type</a></span></dt> +<dt><span class="section"><a href="value_traits/properties.html">General + Type Properties</a></span></dt> +<dt><span class="section"><a href="value_traits/relate.html">Relationships + Between Two Types</a></span></dt> +<dt><span class="section"><a href="value_traits/operators.html">Operator + Type Traits</a></span></dt> +</dl></div> +<p> + These traits are all <span class="emphasis"><em>value traits</em></span>, which is to say the + traits classes all inherit from <a class="link" href="../reference/integral_constant.html" title="integral_constant">integral_constant</a>, + 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 <code class="computeroutput"><a class="link" href="../reference/alignment_of.html" title="alignment_of">alignment_of</a></code>, + <code class="computeroutput"><a class="link" href="../reference/rank.html" title="rank">rank</a></code> + and <code class="computeroutput"><a class="link" href="../reference/extent.html" title="extent">extent</a></code>). + </p> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="../category.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../category.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="value_traits/primary.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/category/value_traits/operators.html b/libs/type_traits/doc/html/boost_typetraits/category/value_traits/operators.html new file mode 100644 index 0000000000..dc58ec30cd --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/category/value_traits/operators.html @@ -0,0 +1,1445 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>Operator Type Traits</title> +<link rel="stylesheet" href="../../../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../../../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../value_traits.html" title="Type Traits that Describe the Properties of a Type"> +<link rel="prev" href="relate.html" title="Relationships Between Two Types"> +<link rel="next" href="../transform.html" title="Type Traits that Transform One Type to Another"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../boost.png"></td> +<td align="center"><a href="../../../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="relate.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../value_traits.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="../transform.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h4 class="title"> +<a name="boost_typetraits.category.value_traits.operators"></a><a class="link" href="operators.html" title="Operator Type Traits">Operator + Type Traits</a> +</h4></div></div></div> +<a name="boost_typetraits.category.value_traits.operators.introduction"></a><h6> +<a name="boost_typetraits.category.value_traits.operators.introduction-heading"></a> + <a class="link" href="operators.html#boost_typetraits.category.value_traits.operators.introduction">Introduction</a> + </h6> +<p> + These traits are all <span class="emphasis"><em>value traits</em></span> inheriting from + <a class="link" href="../../reference/integral_constant.html" title="integral_constant">integral_constant</a> + and providing a simple <code class="computeroutput"><span class="keyword">true</span></code> + or <code class="computeroutput"><span class="keyword">false</span></code> boolean <code class="computeroutput"><span class="identifier">value</span></code> which reflects the fact that given + types can or cannot be used with given operators. + </p> +<p> + For example, <code class="computeroutput"><span class="identifier">has_plus</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">>::</span><span class="identifier">value</span></code> + is a <code class="computeroutput"><span class="keyword">bool</span></code> which value is + <code class="computeroutput"><span class="keyword">true</span></code> because it is possible + to add a <code class="computeroutput"><span class="keyword">double</span></code> to an <code class="computeroutput"><span class="keyword">int</span></code> like in the following code: +</p> +<pre class="programlisting"><span class="keyword">int</span> <span class="identifier">i</span><span class="special">;</span> +<span class="keyword">double</span> <span class="identifier">d</span><span class="special">;</span> +<span class="identifier">i</span><span class="special">+</span><span class="identifier">d</span><span class="special">;</span> +</pre> +<p> + It is also possible to know if the result of the operator can be used as + function argument of a given type. For example, <code class="computeroutput"><span class="identifier">has_plus</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">float</span><span class="special">>::</span><span class="identifier">value</span></code> + is <code class="computeroutput"><span class="keyword">true</span></code> because it is possible + to add a <code class="computeroutput"><span class="keyword">double</span></code> to an <code class="computeroutput"><span class="keyword">int</span></code> and the result (<code class="computeroutput"><span class="keyword">double</span></code>) + can be converted to a <code class="computeroutput"><span class="keyword">float</span></code> + argument like in the following code: +</p> +<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">f</span><span class="special">(</span><span class="keyword">float</span><span class="special">)</span> <span class="special">{</span> <span class="special">};</span> +<span class="keyword">int</span> <span class="identifier">i</span><span class="special">;</span> +<span class="keyword">double</span> <span class="identifier">d</span><span class="special">;</span> +<span class="identifier">f</span><span class="special">(</span><span class="identifier">i</span><span class="special">+</span><span class="identifier">d</span><span class="special">);</span> +</pre> +<p> + </p> +<a name="boost_typetraits.category.value_traits.operators.example_of_application"></a><h6> +<a name="boost_typetraits.category.value_traits.operators.example_of_application-heading"></a> + <a class="link" href="operators.html#boost_typetraits.category.value_traits.operators.example_of_application">Example + of application</a> + </h6> +<p> + These traits can be useful to optimize the code for types supporting given + operations. For example a function <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">advance</span></code> + that increases an iterator of a given number of steps could be implemented + as follows: + </p> +<p> + +</p> +<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_plus_assign</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span> + +<span class="keyword">namespace</span> <span class="identifier">detail</span> <span class="special">{</span> +<span class="keyword">template</span> <span class="special"><</span> <span class="keyword">class</span> <span class="identifier">Iterator</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Distance</span><span class="special">,</span> <span class="keyword">bool</span> <span class="identifier">has_plus_assign</span> <span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">advance_impl</span><span class="special">;</span> + +<span class="comment">// this is used if += exists (efficient)</span> +<span class="keyword">template</span> <span class="special"><</span> <span class="keyword">class</span> <span class="identifier">Iterator</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Distance</span> <span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">advance_impl</span><span class="special"><</span><span class="identifier">Iterator</span><span class="special">,</span> <span class="identifier">Distance</span><span class="special">,</span> <span class="keyword">true</span><span class="special">></span> <span class="special">{</span> + <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">()(</span><span class="identifier">Iterator</span> <span class="special">&</span><span class="identifier">i</span><span class="special">,</span> <span class="identifier">Distance</span> <span class="identifier">n</span><span class="special">)</span> <span class="special">{</span> + <span class="identifier">i</span><span class="special">+=</span><span class="identifier">n</span><span class="special">;</span> + <span class="special">}</span> +<span class="special">};</span> + +<span class="comment">// this is use if += does not exists (less efficient but cannot do better)</span> +<span class="keyword">template</span> <span class="special"><</span> <span class="keyword">class</span> <span class="identifier">Iterator</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Distance</span> <span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">advance_impl</span><span class="special"><</span><span class="identifier">Iterator</span><span class="special">,</span> <span class="identifier">Distance</span><span class="special">,</span> <span class="keyword">false</span><span class="special">></span> <span class="special">{</span> + <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">()(</span><span class="identifier">Iterator</span> <span class="special">&</span><span class="identifier">i</span><span class="special">,</span> <span class="identifier">Distance</span> <span class="identifier">n</span><span class="special">)</span> <span class="special">{</span> + <span class="keyword">if</span> <span class="special">(</span><span class="identifier">n</span><span class="special">></span><span class="number">0</span><span class="special">)</span> <span class="special">{</span> + <span class="keyword">while</span> <span class="special">(</span><span class="identifier">n</span><span class="special">--)</span> <span class="special">++</span><span class="identifier">i</span><span class="special">;</span> + <span class="special">}</span> <span class="keyword">else</span> <span class="special">{</span> + <span class="keyword">while</span> <span class="special">(</span><span class="identifier">n</span><span class="special">++)</span> <span class="special">--</span><span class="identifier">i</span><span class="special">;</span> + <span class="special">}</span> + <span class="special">}</span> +<span class="special">};</span> +<span class="special">}</span> <span class="comment">// namespace detail</span> + +<span class="keyword">template</span> <span class="special"><</span> <span class="keyword">class</span> <span class="identifier">Iterator</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Distance</span> <span class="special">></span> +<span class="keyword">inline</span> <span class="keyword">void</span> <span class="identifier">advance</span><span class="special">(</span><span class="identifier">Iterator</span> <span class="special">&</span><span class="identifier">i</span><span class="special">,</span> <span class="identifier">Distance</span> <span class="identifier">n</span><span class="special">)</span> <span class="special">{</span> + <span class="identifier">detail</span><span class="special">::</span><span class="identifier">advance_impl</span><span class="special"><</span> <span class="identifier">Iterator</span><span class="special">,</span> <span class="identifier">Distance</span><span class="special">,</span> <span class="special">::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_plus_assign</span><span class="special"><</span><span class="identifier">Iterator</span><span class="special">>::</span><span class="identifier">value</span> <span class="special">>()(</span><span class="identifier">i</span><span class="special">,</span> <span class="identifier">n</span><span class="special">);</span> +<span class="special">}</span> +</pre> +<p> + </p> +<p> + Then the compiler chooses the most efficient implementation according to + the type's ability to perform <code class="computeroutput"><span class="special">+=</span></code> + operation: + </p> +<p> + +</p> +<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">iostream</span><span class="special">></span> + +<span class="keyword">class</span> <span class="identifier">with</span> <span class="special">{</span> + <span class="keyword">int</span> <span class="identifier">m_i</span><span class="special">;</span> + <span class="keyword">public</span><span class="special">:</span> + <span class="identifier">with</span><span class="special">(</span><span class="keyword">int</span> <span class="identifier">i</span><span class="special">=</span><span class="number">0</span><span class="special">)</span> <span class="special">:</span> <span class="identifier">m_i</span><span class="special">(</span><span class="identifier">i</span><span class="special">)</span> <span class="special">{</span> <span class="special">}</span> + <span class="identifier">with</span> <span class="special">&</span><span class="keyword">operator</span><span class="special">+=(</span><span class="keyword">int</span> <span class="identifier">rhs</span><span class="special">)</span> <span class="special">{</span> <span class="identifier">m_i</span><span class="special">+=</span><span class="identifier">rhs</span><span class="special">;</span> <span class="keyword">return</span> <span class="special">*</span><span class="keyword">this</span><span class="special">;</span> <span class="special">}</span> + <span class="keyword">operator</span> <span class="keyword">int</span> <span class="keyword">const</span> <span class="special">()</span> <span class="special">{</span> <span class="keyword">return</span> <span class="identifier">m_i</span><span class="special">;</span> <span class="special">}</span> +<span class="special">};</span> + +<span class="keyword">class</span> <span class="identifier">without</span> <span class="special">{</span> + <span class="keyword">int</span> <span class="identifier">m_i</span><span class="special">;</span> + <span class="keyword">public</span><span class="special">:</span> + <span class="identifier">without</span><span class="special">(</span><span class="keyword">int</span> <span class="identifier">i</span><span class="special">=</span><span class="number">0</span><span class="special">)</span> <span class="special">:</span> <span class="identifier">m_i</span><span class="special">(</span><span class="identifier">i</span><span class="special">)</span> <span class="special">{</span> <span class="special">}</span> + <span class="identifier">without</span> <span class="special">&</span><span class="keyword">operator</span><span class="special">++()</span> <span class="special">{</span> <span class="special">++</span><span class="identifier">m_i</span><span class="special">;</span> <span class="keyword">return</span> <span class="special">*</span><span class="keyword">this</span><span class="special">;</span> <span class="special">}</span> + <span class="identifier">without</span> <span class="special">&</span><span class="keyword">operator</span><span class="special">--()</span> <span class="special">{</span> <span class="special">--</span><span class="identifier">m_i</span><span class="special">;</span> <span class="keyword">return</span> <span class="special">*</span><span class="keyword">this</span><span class="special">;</span> <span class="special">}</span> + <span class="keyword">operator</span> <span class="keyword">int</span> <span class="keyword">const</span> <span class="special">()</span> <span class="special">{</span> <span class="keyword">return</span> <span class="identifier">m_i</span><span class="special">;</span> <span class="special">}</span> +<span class="special">};</span> + +<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span> <span class="special">{</span> + <span class="identifier">with</span> <span class="identifier">i</span><span class="special">=</span><span class="number">0</span><span class="special">;</span> + <span class="identifier">advance</span><span class="special">(</span><span class="identifier">i</span><span class="special">,</span> <span class="number">10</span><span class="special">);</span> <span class="comment">// uses +=</span> + <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special"><<</span><span class="string">"with: "</span><span class="special"><<</span><span class="identifier">i</span><span class="special"><<</span><span class="char">'\n'</span><span class="special">;</span> + <span class="identifier">without</span> <span class="identifier">j</span><span class="special">=</span><span class="number">0</span><span class="special">;</span> + <span class="identifier">advance</span><span class="special">(</span><span class="identifier">j</span><span class="special">,</span> <span class="number">10</span><span class="special">);</span> <span class="comment">// uses ++</span> + <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special"><<</span><span class="string">"without: "</span><span class="special"><<</span><span class="identifier">j</span><span class="special"><<</span><span class="char">'\n'</span><span class="special">;</span> + <span class="keyword">return</span> <span class="number">0</span><span class="special">;</span> +<span class="special">}</span> +</pre> +<p> + </p> +<a name="boost_typetraits.category.value_traits.operators.description"></a><h6> +<a name="boost_typetraits.category.value_traits.operators.description-heading"></a> + <a class="link" href="operators.html#boost_typetraits.category.value_traits.operators.description">Description</a> + </h6> +<p> + The syntax is the following: +</p> +<pre class="programlisting"><span class="keyword">template</span> <code class="computeroutput"><span class="special"><</span> <span class="keyword">class</span> <span class="identifier">Rhs</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Ret</span><span class="special">=</span><span class="identifier">dont_care</span> <span class="special">></span></code> <span class="identifier">has_op</span><span class="special">;</span> <span class="comment">// prefix operator</span> +<span class="keyword">template</span> <code class="computeroutput"><span class="special"><</span> <span class="keyword">class</span> <span class="identifier">Lhs</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Ret</span><span class="special">=</span><span class="identifier">dont_care</span> <span class="special">></span></code> <span class="identifier">has_op</span><span class="special">;</span> <span class="comment">// postfix operator</span> +<span class="keyword">template</span> <code class="computeroutput"><span class="special"><</span> <span class="keyword">class</span> <span class="identifier">Lhs</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Rhs</span><span class="special">=</span><span class="identifier">Lhs</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Ret</span><span class="special">=</span><span class="identifier">dont_care</span> <span class="special">></span></code> <span class="identifier">has_op</span><span class="special">;</span> <span class="comment">// binary operator</span> +</pre> +<p> + where: + </p> +<div class="itemizedlist"><ul class="itemizedlist" type="disc"> +<li class="listitem"> + op represents the operator name + </li> +<li class="listitem"> + <code class="computeroutput"><span class="identifier">Lhs</span></code> is the type used + at the left hand side of <code class="computeroutput"><span class="keyword">operator</span> + <span class="identifier">op</span></code>, + </li> +<li class="listitem"> + <code class="computeroutput"><span class="identifier">Rhs</span></code> is the type used + at the right hand side of <code class="computeroutput"><span class="keyword">operator</span> + <span class="identifier">op</span></code>, + </li> +<li class="listitem"> + <code class="computeroutput"><span class="identifier">Ret</span></code> is the type for + which we want to know if the result of <code class="computeroutput"><span class="keyword">operator</span> + <span class="identifier">op</span></code> can be converted to. + </li> +</ul></div> +<p> + The default behaviour (<code class="computeroutput"><span class="identifier">Ret</span><span class="special">=</span><span class="identifier">dont_care</span></code>) + is to not check for the return value of the operator. If <code class="computeroutput"><span class="identifier">Ret</span></code> is different from the default <code class="computeroutput"><span class="identifier">dont_care</span></code>, the return value is checked + to be convertible to <code class="computeroutput"><span class="identifier">Ret</span></code>. + Convertible to <code class="computeroutput"><span class="identifier">Ret</span></code> means + that the return value can be used as argument to a function expecting + <code class="computeroutput"><span class="identifier">Ret</span></code>: +</p> +<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">Ret</span><span class="special">);</span> +<span class="identifier">Lhs</span> <span class="identifier">lhs</span><span class="special">;</span> +<span class="identifier">Rhs</span> <span class="identifier">rhs</span><span class="special">;</span> +<span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">+</span><span class="identifier">rhs</span><span class="special">);</span> <span class="comment">// is valid if has_plus<Lhs, Rhs, Ret>::value==true</span> +</pre> +<p> + If <code class="computeroutput"><span class="identifier">Ret</span><span class="special">=</span><span class="keyword">void</span></code>, the return type is checked to be exactly + <code class="computeroutput"><span class="keyword">void</span></code>. + </p> +<p> + The following tables give the list of supported binary, prefix and postfix + operators. + </p> +<div class="table"> +<a name="boost_typetraits.category.value_traits.operators.supported_prefix_operators"></a><p class="title"><b>Table 1.4. Supported prefix operators</b></p> +<div class="table-contents"><table class="table" summary="Supported prefix operators"> +<colgroup> +<col> +<col> +</colgroup> +<thead><tr> +<th> + <p> + prefix operator + </p> + </th> +<th> + <p> + trait name + </p> + </th> +</tr></thead> +<tbody> +<tr> +<td> + <p> + <code class="computeroutput"><span class="special">!</span></code> + </p> + </td> +<td> + <p> + <a class="link" href="../../reference/has_logical_not.html" title="has_logical_not"><code class="computeroutput"><span class="identifier">has_logical_not</span></code></a> <code class="computeroutput"><span class="special"><</span> <span class="keyword">class</span> + <span class="identifier">Rhs</span><span class="special">,</span> + <span class="keyword">class</span> <span class="identifier">Ret</span><span class="special">=</span><span class="identifier">dont_care</span> + <span class="special">></span></code> + </p> + </td> +</tr> +<tr> +<td> + <p> + <code class="computeroutput"><span class="special">+</span></code> + </p> + </td> +<td> + <p> + <a class="link" href="../../reference/has_unary_plus.html" title="has_unary_plus"><code class="computeroutput"><span class="identifier">has_unary_plus</span></code></a> + </p> + </td> +</tr> +<tr> +<td> + <p> + <code class="computeroutput"><span class="special">-</span></code> + </p> + </td> +<td> + <p> + <a class="link" href="../../reference/has_unary_minus.html" title="has_unary_minus"><code class="computeroutput"><span class="identifier">has_unary_minus</span></code></a> and + <a class="link" href="../../reference/has_negate.html" title="has_negate"><code class="computeroutput"><span class="identifier">has_negate</span></code></a> + </p> + </td> +</tr> +<tr> +<td> + <p> + <code class="computeroutput"><span class="special">~</span></code> + </p> + </td> +<td> + <p> + <a class="link" href="../../reference/has_complement.html" title="has_complement"><code class="computeroutput"><span class="identifier">has_complement</span></code></a> + </p> + </td> +</tr> +<tr> +<td> + <p> + <code class="computeroutput"><span class="special">*</span></code> + </p> + </td> +<td> + <p> + <a class="link" href="../../reference/has_dereference.html" title="has_dereference"><code class="computeroutput"><span class="identifier">has_dereference</span></code></a> + </p> + </td> +</tr> +<tr> +<td> + <p> + <code class="computeroutput"><span class="special">++</span></code> + </p> + </td> +<td> + <p> + <a class="link" href="../../reference/has_pre_increment.html" title="has_pre_increment"><code class="computeroutput"><span class="identifier">has_pre_increment</span></code></a> + </p> + </td> +</tr> +<tr> +<td> + <p> + <code class="computeroutput"><span class="special">--</span></code> + </p> + </td> +<td> + <p> + <a class="link" href="../../reference/has_pre_decrement.html" title="has_pre_decrement"><code class="computeroutput"><span class="identifier">has_pre_decrement</span></code></a> + </p> + </td> +</tr> +</tbody> +</table></div> +</div> +<br class="table-break"><div class="table"> +<a name="boost_typetraits.category.value_traits.operators.supported_postfix_operators"></a><p class="title"><b>Table 1.5. Supported postfix operators</b></p> +<div class="table-contents"><table class="table" summary="Supported postfix operators"> +<colgroup> +<col> +<col> +</colgroup> +<thead><tr> +<th> + <p> + postfix operator + </p> + </th> +<th> + <p> + trait name + </p> + </th> +</tr></thead> +<tbody> +<tr> +<td> + <p> + <code class="computeroutput"><span class="special">++</span></code> + </p> + </td> +<td> + <p> + <a class="link" href="../../reference/has_post_increment.html" title="has_post_increment"><code class="computeroutput"><span class="identifier">has_post_increment</span></code></a> + <code class="computeroutput"><span class="special"><</span> <span class="keyword">class</span> + <span class="identifier">Lhs</span><span class="special">,</span> + <span class="keyword">class</span> <span class="identifier">Ret</span><span class="special">=</span><span class="identifier">dont_care</span> + <span class="special">></span></code> + </p> + </td> +</tr> +<tr> +<td> + <p> + <code class="computeroutput"><span class="special">--</span></code> + </p> + </td> +<td> + <p> + <a class="link" href="../../reference/has_post_decrement.html" title="has_post_decrement"><code class="computeroutput"><span class="identifier">has_post_decrement</span></code></a> + </p> + </td> +</tr> +</tbody> +</table></div> +</div> +<br class="table-break"><div class="table"> +<a name="boost_typetraits.category.value_traits.operators.supported_binary_operators"></a><p class="title"><b>Table 1.6. Supported binary operators</b></p> +<div class="table-contents"><table class="table" summary="Supported binary operators"> +<colgroup> +<col> +<col> +</colgroup> +<thead><tr> +<th> + <p> + binary operator + </p> + </th> +<th> + <p> + trait name + </p> + </th> +</tr></thead> +<tbody> +<tr> +<td> + <p> + <code class="computeroutput"><span class="special">+</span></code> + </p> + </td> +<td> + <p> + <a class="link" href="../../reference/has_plus.html" title="has_plus"><code class="computeroutput"><span class="identifier">has_plus</span></code></a> <code class="computeroutput"><span class="special"><</span> <span class="keyword">class</span> + <span class="identifier">Lhs</span><span class="special">,</span> + <span class="keyword">class</span> <span class="identifier">Rhs</span><span class="special">=</span><span class="identifier">Lhs</span><span class="special">,</span> <span class="keyword">class</span> + <span class="identifier">Ret</span><span class="special">=</span><span class="identifier">dont_care</span> <span class="special">></span></code> + </p> + </td> +</tr> +<tr> +<td> + <p> + <code class="computeroutput"><span class="special">-</span></code> + </p> + </td> +<td> + <p> + <a class="link" href="../../reference/has_minus.html" title="has_minus"><code class="computeroutput"><span class="identifier">has_minus</span></code></a> + </p> + </td> +</tr> +<tr> +<td> + <p> + <code class="computeroutput"><span class="special">*</span></code> + </p> + </td> +<td> + <p> + <a class="link" href="../../reference/has_multiplies.html" title="has_multiplies"><code class="computeroutput"><span class="identifier">has_multiplies</span></code></a> + </p> + </td> +</tr> +<tr> +<td> + <p> + <code class="computeroutput"><span class="special">/</span></code> + </p> + </td> +<td> + <p> + <a class="link" href="../../reference/has_divides.html" title="has_divides"><code class="computeroutput"><span class="identifier">has_divides</span></code></a> + </p> + </td> +</tr> +<tr> +<td> + <p> + <code class="computeroutput"><span class="special">%</span></code> + </p> + </td> +<td> + <p> + <a class="link" href="../../reference/has_modulus.html" title="has_modulus"><code class="computeroutput"><span class="identifier">has_modulus</span></code></a> + </p> + </td> +</tr> +<tr> +<td> + <p> + <code class="computeroutput"><span class="special">+=</span></code> + </p> + </td> +<td> + <p> + <a class="link" href="../../reference/has_plus_assign.html" title="has_plus_assign"><code class="computeroutput"><span class="identifier">has_plus_assign</span></code></a> + </p> + </td> +</tr> +<tr> +<td> + <p> + <code class="computeroutput"><span class="special">-=</span></code> + </p> + </td> +<td> + <p> + <a class="link" href="../../reference/has_minus_assign.html" title="has_minus_assign"><code class="computeroutput"><span class="identifier">has_minus_assign</span></code></a> + </p> + </td> +</tr> +<tr> +<td> + <p> + <code class="computeroutput"><span class="special">*=</span></code> + </p> + </td> +<td> + <p> + <a class="link" href="../../reference/has_multiplies_assign.html" title="has_multiplies_assign"><code class="computeroutput"><span class="identifier">has_multiplies_assign</span></code></a> + </p> + </td> +</tr> +<tr> +<td> + <p> + <code class="computeroutput"><span class="special">/=</span></code> + </p> + </td> +<td> + <p> + <a class="link" href="../../reference/has_divides_assign.html" title="has_divides_assign"><code class="computeroutput"><span class="identifier">has_divides_assign</span></code></a> + </p> + </td> +</tr> +<tr> +<td> + <p> + <code class="computeroutput"><span class="special">%=</span></code> + </p> + </td> +<td> + <p> + <a class="link" href="../../reference/has_modulus_assign.html" title="has_modulus_assign"><code class="computeroutput"><span class="identifier">has_modulus_assign</span></code></a> + </p> + </td> +</tr> +<tr> +<td> + <p> + <code class="computeroutput"><span class="special">&</span></code> + </p> + </td> +<td> + <p> + <a class="link" href="../../reference/has_bit_and.html" title="has_bit_and"><code class="computeroutput"><span class="identifier">has_bit_and</span></code></a> + </p> + </td> +</tr> +<tr> +<td> + <p> + <code class="computeroutput"><span class="special">|</span></code> + </p> + </td> +<td> + <p> + <a class="link" href="../../reference/has_bit_or.html" title="has_bit_or"><code class="computeroutput"><span class="identifier">has_bit_or</span></code></a> + </p> + </td> +</tr> +<tr> +<td> + <p> + <code class="computeroutput"><span class="special">^</span></code> + </p> + </td> +<td> + <p> + <a class="link" href="../../reference/has_bit_xor.html" title="has_bit_xor"><code class="computeroutput"><span class="identifier">has_bit_xor</span></code></a> + </p> + </td> +</tr> +<tr> +<td> + <p> + <code class="computeroutput"><span class="special">&=</span></code> + </p> + </td> +<td> + <p> + <a class="link" href="../../reference/has_bit_and_assign.html" title="has_bit_and_assign"><code class="computeroutput"><span class="identifier">has_bit_and_assign</span></code></a> + </p> + </td> +</tr> +<tr> +<td> + <p> + <code class="computeroutput"><span class="special">|=</span></code> + </p> + </td> +<td> + <p> + <a class="link" href="../../reference/has_bit_or_assign.html" title="has_bit_or_assign"><code class="computeroutput"><span class="identifier">has_bit_or_assign</span></code></a> + </p> + </td> +</tr> +<tr> +<td> + <p> + <code class="computeroutput"><span class="special">^=</span></code> + </p> + </td> +<td> + <p> + <a class="link" href="../../reference/has_bit_xor_assign.html" title="has_bit_xor_assign"><code class="computeroutput"><span class="identifier">has_bit_xor_assign</span></code></a> + </p> + </td> +</tr> +<tr> +<td> + <p> + <code class="computeroutput"><span class="special"><<</span></code> + </p> + </td> +<td> + <p> + <a class="link" href="../../reference/has_left_shift.html" title="has_left_shift"><code class="computeroutput"><span class="identifier">has_left_shift</span></code></a> + </p> + </td> +</tr> +<tr> +<td> + <p> + <code class="computeroutput"><span class="special">>></span></code> + </p> + </td> +<td> + <p> + <a class="link" href="../../reference/has_right_shift.html" title="has_right_shift"><code class="computeroutput"><span class="identifier">has_right_shift</span></code></a> + </p> + </td> +</tr> +<tr> +<td> + <p> + <code class="computeroutput"><span class="special"><<=</span></code> + </p> + </td> +<td> + <p> + <a class="link" href="../../reference/has_left_shift_assign.html" title="has_left_shift_assign"><code class="computeroutput"><span class="identifier">has_left_shift_assign</span></code></a> + </p> + </td> +</tr> +<tr> +<td> + <p> + <code class="computeroutput"><span class="special">>>=</span></code> + </p> + </td> +<td> + <p> + <a class="link" href="../../reference/has_right_shift_assign.html" title="has_right_shift_assign"><code class="computeroutput"><span class="identifier">has_right_shift_assign</span></code></a> + </p> + </td> +</tr> +<tr> +<td> + <p> + <code class="computeroutput"><span class="special">==</span></code> + </p> + </td> +<td> + <p> + <a class="link" href="../../reference/has_equal_to.html" title="has_equal_to"><code class="computeroutput"><span class="identifier">has_equal_to</span></code></a> + </p> + </td> +</tr> +<tr> +<td> + <p> + <code class="computeroutput"><span class="special">!=</span></code> + </p> + </td> +<td> + <p> + <a class="link" href="../../reference/has_not_equal_to.html" title="has_not_equal_to"><code class="computeroutput"><span class="identifier">has_not_equal_to</span></code></a> + </p> + </td> +</tr> +<tr> +<td> + <p> + <code class="computeroutput"><span class="special"><</span></code> + </p> + </td> +<td> + <p> + <a class="link" href="../../reference/has_less.html" title="has_less"><code class="computeroutput"><span class="identifier">has_less</span></code></a> + </p> + </td> +</tr> +<tr> +<td> + <p> + <code class="computeroutput"><span class="special"><=</span></code> + </p> + </td> +<td> + <p> + <a class="link" href="../../reference/has_less_equal.html" title="has_less_equal"><code class="computeroutput"><span class="identifier">has_less_equal</span></code></a> + </p> + </td> +</tr> +<tr> +<td> + <p> + <code class="computeroutput"><span class="special">></span></code> + </p> + </td> +<td> + <p> + <a class="link" href="../../reference/has_greater.html" title="has_greater"><code class="computeroutput"><span class="identifier">has_greater</span></code></a> + </p> + </td> +</tr> +<tr> +<td> + <p> + <code class="computeroutput"><span class="special">>=</span></code> + </p> + </td> +<td> + <p> + <a class="link" href="../../reference/has_greater_equal.html" title="has_greater_equal"><code class="computeroutput"><span class="identifier">has_greater_equal</span></code></a> + </p> + </td> +</tr> +<tr> +<td> + <p> + <code class="computeroutput"><span class="special">&&</span></code> + </p> + </td> +<td> + <p> + <a class="link" href="../../reference/has_logical_and.html" title="has_logical_and"><code class="computeroutput"><span class="identifier">has_logical_and</span></code></a> + </p> + </td> +</tr> +<tr> +<td> + <p> + <code class="computeroutput"><span class="special">||</span></code> + </p> + </td> +<td> + <p> + <a class="link" href="../../reference/has_logical_or.html" title="has_logical_or"><code class="computeroutput"><span class="identifier">has_logical_or</span></code></a> + </p> + </td> +</tr> +</tbody> +</table></div> +</div> +<br class="table-break"><p> + The following operators are not supported because they could not be implemented + using the same technique: <code class="computeroutput"><span class="keyword">operator</span><span class="special">=</span></code>, <code class="computeroutput"><span class="keyword">operator</span><span class="special">-></span></code>, <code class="computeroutput"><span class="keyword">operator</span><span class="special">&</span></code>, <code class="computeroutput"><span class="keyword">operator</span><span class="special">[]</span></code>, <code class="computeroutput"><span class="keyword">operator</span><span class="special">,</span></code>, <code class="computeroutput"><span class="keyword">operator</span><span class="special">()</span></code>, <code class="computeroutput"><span class="keyword">operator</span> + <span class="keyword">new</span></code>. + </p> +<a name="boost_typetraits.category.value_traits.operators.cv_qualifiers_and_references"></a><h6> +<a name="boost_typetraits.category.value_traits.operators.cv_qualifiers_and_references-heading"></a> + <a class="link" href="operators.html#boost_typetraits.category.value_traits.operators.cv_qualifiers_and_references">cv + qualifiers and references</a> + </h6> +<p> + A reference sign <code class="computeroutput"><span class="special">&</span></code> in + the operator argument is ignored so that <code class="computeroutput"><span class="identifier">has_plus</span><span class="special"><</span> <span class="keyword">int</span><span class="special">&,</span> <span class="keyword">double</span><span class="special">&</span> <span class="special">>::</span><span class="identifier">value</span><span class="special">==</span><span class="identifier">has_plus</span><span class="special"><</span> + <span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span> <span class="special">>::</span><span class="identifier">value</span></code>. This has been chosen because if + the following code works (does not work): +</p> +<pre class="programlisting"><span class="keyword">int</span> <span class="identifier">i</span><span class="special">;</span> +<span class="keyword">double</span> <span class="identifier">d</span><span class="special">;</span> +<span class="identifier">i</span><span class="special">+</span><span class="identifier">d</span><span class="special">;</span> +</pre> +<p> + the following code also works (does not work): +</p> +<pre class="programlisting"><span class="keyword">int</span> <span class="special">&</span><span class="identifier">ir</span><span class="special">=</span><span class="identifier">i</span><span class="special">;</span> +<span class="keyword">double</span> <span class="special">&</span><span class="identifier">dr</span><span class="special">=</span><span class="identifier">d</span><span class="special">;</span> +<span class="identifier">ir</span><span class="special">+</span><span class="identifier">dr</span><span class="special">;</span> +</pre> +<p> + </p> +<p> + It was not possible to handle properly the <code class="computeroutput"><span class="keyword">volatile</span></code> + qualifier so that any construct using this qualifier has undefined behavior. + </p> +<p> + As a help, the following tables give the necessary conditions over each + trait template argument for the trait <code class="computeroutput"><span class="identifier">value</span></code> + to be <code class="computeroutput"><span class="keyword">true</span></code>. They are non sufficient + conditions because the conditions must be <code class="computeroutput"><span class="keyword">true</span></code> + for all arguments and return type for <code class="computeroutput"><span class="identifier">value</span></code> + to be <code class="computeroutput"><span class="keyword">true</span></code>. + </p> +<div class="table"> +<a name="boost_typetraits.category.value_traits.operators.necessary_and_non_sufficient_condition_on_operator_argument_for_value_to_be_true"></a><p class="title"><b>Table 1.7. necessary and non sufficient condition on operator argument for + value to be true</b></p> +<div class="table-contents"><table class="table" summary="necessary and non sufficient condition on operator argument for + value to be true"> +<colgroup> +<col> +<col> +<col> +<col> +</colgroup> +<thead><tr> +<th> + <p> + operator declaration + </p> + </th> +<th> + <p> + <code class="computeroutput"><span class="identifier">has_op</span><span class="special"><</span> + <span class="keyword">void</span> <span class="special">></span></code> + </p> + </th> +<th> + <p> + <code class="computeroutput"><span class="identifier">has_op</span><span class="special"><</span> + <span class="identifier">Arg</span> <span class="special">></span></code> + and <code class="computeroutput"><span class="identifier">has_op</span><span class="special"><</span> + <span class="identifier">Arg</span><span class="special">&</span> + <span class="special">></span></code> + </p> + </th> +<th> + <p> + <code class="computeroutput"><span class="identifier">has_op</span><span class="special"><</span> + <span class="identifier">Arg</span> <span class="keyword">const</span> + <span class="special">></span></code> and <code class="computeroutput"><span class="identifier">has_op</span><span class="special"><</span> + <span class="identifier">Arg</span> <span class="keyword">const</span><span class="special">&</span> <span class="special">></span></code> + </p> + </th> +</tr></thead> +<tbody> +<tr> +<td> + <p> + <code class="computeroutput"><span class="keyword">operator</span></code>@<code class="computeroutput"><span class="special">(</span><span class="identifier">Arg</span><span class="special">)</span></code> + </p> + </td> +<td> + <p> + false + </p> + </td> +<td> + <p> + true + </p> + </td> +<td> + <p> + true + </p> + </td> +</tr> +<tr> +<td> + <p> + <code class="computeroutput"><span class="keyword">operator</span></code>@<code class="computeroutput"><span class="special">(</span><span class="identifier">Arg</span> + <span class="keyword">const</span><span class="special">)</span></code> + </p> + </td> +<td> + <p> + false + </p> + </td> +<td> + <p> + true + </p> + </td> +<td> + <p> + true + </p> + </td> +</tr> +<tr> +<td> + <p> + <code class="computeroutput"><span class="keyword">operator</span></code>@<code class="computeroutput"><span class="special">(</span><span class="identifier">Arg</span> + <span class="special">&)</span></code> + </p> + </td> +<td> + <p> + false + </p> + </td> +<td> + <p> + true + </p> + </td> +<td> + <p> + false + </p> + </td> +</tr> +<tr> +<td> + <p> + <code class="computeroutput"><span class="keyword">operator</span></code>@<code class="computeroutput"><span class="special">(</span><span class="identifier">Arg</span> + <span class="keyword">const</span> <span class="special">&)</span></code> + </p> + </td> +<td> + <p> + false + </p> + </td> +<td> + <p> + true + </p> + </td> +<td> + <p> + true + </p> + </td> +</tr> +</tbody> +</table></div> +</div> +<br class="table-break"><div class="table"> +<a name="boost_typetraits.category.value_traits.operators.necessary_and_non_sufficient_condition_on_operator_return_type_for_value_to_be_true"></a><p class="title"><b>Table 1.8. necessary and non sufficient condition on operator return type for + value to be true</b></p> +<div class="table-contents"><table class="table" summary="necessary and non sufficient condition on operator return type for + value to be true"> +<colgroup> +<col> +<col> +<col> +<col> +<col> +<col> +</colgroup> +<thead><tr> +<th> + <p> + operator declaration + </p> + </th> +<th> + <p> + <code class="computeroutput"><span class="identifier">has_op</span><span class="special"><</span> + <span class="special">...,</span> <span class="keyword">void</span> + <span class="special">></span></code> + </p> + </th> +<th> + <p> + <code class="computeroutput"><span class="identifier">has_op</span><span class="special"><</span> + <span class="special">...,</span> <span class="identifier">Ret</span> + <span class="special">></span></code> + </p> + </th> +<th> + <p> + <code class="computeroutput"><span class="identifier">has_op</span><span class="special"><</span> + <span class="special">...,</span> <span class="identifier">Ret</span> + <span class="keyword">const</span> <span class="special">></span></code> + </p> + </th> +<th> + <p> + <code class="computeroutput"><span class="identifier">has_op</span><span class="special"><</span> + <span class="special">...,</span> <span class="identifier">Ret</span> + <span class="special">&</span> <span class="special">></span></code> + </p> + </th> +<th> + <p> + <code class="computeroutput"><span class="identifier">has_op</span><span class="special"><</span> + <span class="special">...,</span> <span class="identifier">Ret</span> + <span class="keyword">const</span> <span class="special">&</span> + <span class="special">></span></code> + </p> + </th> +</tr></thead> +<tbody> +<tr> +<td> + <p> + <code class="computeroutput"><span class="keyword">void</span> <span class="keyword">operator</span></code>@<code class="computeroutput"><span class="special">(...)</span></code> + </p> + </td> +<td> + <p> + true + </p> + </td> +<td> + <p> + false + </p> + </td> +<td> + <p> + false + </p> + </td> +<td> + <p> + false + </p> + </td> +<td> + <p> + false + </p> + </td> +</tr> +<tr> +<td> + <p> + <code class="computeroutput"><span class="identifier">Ret</span> <span class="keyword">operator</span></code>@<code class="computeroutput"><span class="special">(...)</span></code> + </p> + </td> +<td> + <p> + false + </p> + </td> +<td> + <p> + true + </p> + </td> +<td> + <p> + true + </p> + </td> +<td> + <p> + false + </p> + </td> +<td> + <p> + true + </p> + </td> +</tr> +<tr> +<td> + <p> + <code class="computeroutput"><span class="identifier">Ret</span> <span class="keyword">const</span> + <span class="keyword">operator</span></code>@<code class="computeroutput"><span class="special">(...)</span></code> + </p> + </td> +<td> + <p> + false + </p> + </td> +<td> + <p> + true + </p> + </td> +<td> + <p> + true + </p> + </td> +<td> + <p> + false + </p> + </td> +<td> + <p> + true + </p> + </td> +</tr> +<tr> +<td> + <p> + <code class="computeroutput"><span class="identifier">Ret</span> <span class="special">&</span> + <span class="keyword">operator</span></code>@<code class="computeroutput"><span class="special">(...)</span></code> + </p> + </td> +<td> + <p> + false + </p> + </td> +<td> + <p> + true + </p> + </td> +<td> + <p> + true + </p> + </td> +<td> + <p> + true + </p> + </td> +<td> + <p> + true + </p> + </td> +</tr> +<tr> +<td> + <p> + <code class="computeroutput"><span class="identifier">Ret</span> <span class="keyword">const</span> + <span class="special">&</span> <span class="keyword">operator</span></code>@<code class="computeroutput"><span class="special">(...)</span></code> + </p> + </td> +<td> + <p> + false + </p> + </td> +<td> + <p> + true + </p> + </td> +<td> + <p> + true + </p> + </td> +<td> + <p> + false + </p> + </td> +<td> + <p> + true + </p> + </td> +</tr> +</tbody> +</table></div> +</div> +<br class="table-break"><a name="boost_typetraits.category.value_traits.operators.implementation"></a><h6> +<a name="boost_typetraits.category.value_traits.operators.implementation-heading"></a> + <a class="link" href="operators.html#boost_typetraits.category.value_traits.operators.implementation">Implementation</a> + </h6> +<p> + The implementation consists in only header files. The following headers + should included first: +</p> +<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_operator</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></pre> +<p> + or +</p> +<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_op</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></pre> +<p> + where <code class="literal">op</code> is the textual name chosen for the wanted operator. + The first method includes all operator traits. + </p> +<p> + All traits are implemented the same way using preprocessor macros to avoid + code duplication. The main files are in <code class="literal">boost/type_traits/detail</code>: + <code class="literal">has_binary_operator.hpp</code>, <code class="literal">has_prefix_operator.hpp</code> + and <code class="literal">has_postfix_operator.hpp</code>. The example of prefix + <code class="computeroutput"><span class="keyword">operator</span><span class="special">-</span></code> + is presented below: + </p> +<p> + +</p> +<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span> +<span class="keyword">namespace</span> <span class="identifier">detail</span> <span class="special">{</span> + +<span class="comment">// This namespace ensures that argument-dependent name lookup does not mess things up.</span> +<span class="keyword">namespace</span> <span class="identifier">has_unary_minus_impl</span> <span class="special">{</span> + +<span class="comment">// 1. a function to have an instance of type T without requiring T to be default</span> +<span class="comment">// constructible</span> +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">></span> <span class="identifier">T</span> <span class="special">&</span><span class="identifier">make</span><span class="special">();</span> + + +<span class="comment">// 2. we provide our operator definition for types that do not have one already</span> + +<span class="comment">// a type returned from operator- when no such operator is</span> +<span class="comment">// found in the type's own namespace (our own operator is used) so that we have</span> +<span class="comment">// a means to know that our operator was used</span> +<span class="keyword">struct</span> <span class="identifier">no_operator</span> <span class="special">{</span> <span class="special">};</span> + +<span class="comment">// this class allows implicit conversions and makes the following operator</span> +<span class="comment">// definition less-preferred than any other such operators that might be found</span> +<span class="comment">// via argument-dependent name lookup</span> +<span class="keyword">struct</span> <span class="identifier">any</span> <span class="special">{</span> <span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> <span class="identifier">any</span><span class="special">(</span><span class="identifier">T</span> <span class="keyword">const</span><span class="special">&);</span> <span class="special">};</span> + +<span class="comment">// when operator- is not available, this one is used</span> +<span class="identifier">no_operator</span> <span class="keyword">operator</span><span class="special">-(</span><span class="keyword">const</span> <span class="identifier">any</span><span class="special">&);</span> + + +<span class="comment">// 3. checks if the operator returns void or not</span> +<span class="comment">// conditions: Rhs!=void</span> + +<span class="comment">// we first redefine "operator," so that we have no compilation error if</span> +<span class="comment">// operator- returns void and we can use the return type of</span> +<span class="comment">// (-rhs, returns_void_t()) to deduce if operator- returns void or not:</span> +<span class="comment">// - operator- returns void -> (-rhs, returns_void_t()) returns returns_void_t</span> +<span class="comment">// - operator- returns !=void -> (-rhs, returns_void_t()) returns int</span> +<span class="keyword">struct</span> <span class="identifier">returns_void_t</span> <span class="special">{</span> <span class="special">};</span> +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">></span> <span class="keyword">int</span> <span class="keyword">operator</span><span class="special">,(</span><span class="keyword">const</span> <span class="identifier">T</span><span class="special">&,</span> <span class="identifier">returns_void_t</span><span class="special">);</span> +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">></span> <span class="keyword">int</span> <span class="keyword">operator</span><span class="special">,(</span><span class="keyword">const</span> <span class="keyword">volatile</span> <span class="identifier">T</span><span class="special">&,</span> <span class="identifier">returns_void_t</span><span class="special">);</span> + +<span class="comment">// this intermediate trait has member value of type bool:</span> +<span class="comment">// - value==true -> operator- returns void</span> +<span class="comment">// - value==false -> operator- does not return void</span> +<span class="keyword">template</span> <span class="special"><</span> <span class="keyword">typename</span> <span class="identifier">Rhs</span> <span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">operator_returns_void</span> <span class="special">{</span> + <span class="comment">// overloads of function returns_void make the difference</span> + <span class="comment">// yes_type and no_type have different size by construction</span> + <span class="keyword">static</span> <span class="special">::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">type_traits</span><span class="special">::</span><span class="identifier">yes_type</span> <span class="identifier">returns_void</span><span class="special">(</span><span class="identifier">returns_void_t</span><span class="special">);</span> + <span class="keyword">static</span> <span class="special">::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">type_traits</span><span class="special">::</span><span class="identifier">no_type</span> <span class="identifier">returns_void</span><span class="special">(</span><span class="keyword">int</span><span class="special">);</span> + <span class="keyword">static</span> <span class="keyword">const</span> <span class="keyword">bool</span> <span class="identifier">value</span> <span class="special">=</span> <span class="keyword">sizeof</span><span class="special">(::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">type_traits</span><span class="special">::</span><span class="identifier">yes_type</span><span class="special">)==</span><span class="keyword">sizeof</span><span class="special">(</span><span class="identifier">returns_void</span><span class="special">((-</span><span class="identifier">make</span><span class="special"><</span><span class="identifier">Rhs</span><span class="special">>(),</span><span class="identifier">returns_void_t</span><span class="special">())));</span> +<span class="special">};</span> + + +<span class="comment">// 4. checks if the return type is Ret or Ret==dont_care</span> +<span class="comment">// conditions: Rhs!=void</span> + +<span class="keyword">struct</span> <span class="identifier">dont_care</span> <span class="special">{</span> <span class="special">};</span> + +<span class="keyword">template</span> <span class="special"><</span> <span class="keyword">typename</span> <span class="identifier">Rhs</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">Ret</span><span class="special">,</span> <span class="keyword">bool</span> <span class="identifier">Returns_void</span> <span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">operator_returns_Ret</span><span class="special">;</span> + +<span class="keyword">template</span> <span class="special"><</span> <span class="keyword">typename</span> <span class="identifier">Rhs</span> <span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">operator_returns_Ret</span> <span class="special"><</span> <span class="identifier">Rhs</span><span class="special">,</span> <span class="identifier">dont_care</span><span class="special">,</span> <span class="keyword">true</span> <span class="special">></span> <span class="special">{</span> + <span class="keyword">static</span> <span class="keyword">const</span> <span class="keyword">bool</span> <span class="identifier">value</span> <span class="special">=</span> <span class="keyword">true</span><span class="special">;</span> +<span class="special">};</span> + +<span class="keyword">template</span> <span class="special"><</span> <span class="keyword">typename</span> <span class="identifier">Rhs</span> <span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">operator_returns_Ret</span> <span class="special"><</span> <span class="identifier">Rhs</span><span class="special">,</span> <span class="identifier">dont_care</span><span class="special">,</span> <span class="keyword">false</span> <span class="special">></span> <span class="special">{</span> + <span class="keyword">static</span> <span class="keyword">const</span> <span class="keyword">bool</span> <span class="identifier">value</span> <span class="special">=</span> <span class="keyword">true</span><span class="special">;</span> +<span class="special">};</span> + +<span class="keyword">template</span> <span class="special"><</span> <span class="keyword">typename</span> <span class="identifier">Rhs</span> <span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">operator_returns_Ret</span> <span class="special"><</span> <span class="identifier">Rhs</span><span class="special">,</span> <span class="keyword">void</span><span class="special">,</span> <span class="keyword">true</span> <span class="special">></span> <span class="special">{</span> + <span class="keyword">static</span> <span class="keyword">const</span> <span class="keyword">bool</span> <span class="keyword">bool</span> <span class="identifier">value</span> <span class="special">=</span> <span class="keyword">true</span><span class="special">;</span> +<span class="special">};</span> + +<span class="keyword">template</span> <span class="special"><</span> <span class="keyword">typename</span> <span class="identifier">Rhs</span> <span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">operator_returns_Ret</span> <span class="special"><</span> <span class="identifier">Rhs</span><span class="special">,</span> <span class="keyword">void</span><span class="special">,</span> <span class="keyword">false</span> <span class="special">></span> <span class="special">{</span> + <span class="keyword">static</span> <span class="keyword">const</span> <span class="keyword">bool</span> <span class="identifier">value</span> <span class="special">=</span> <span class="keyword">false</span><span class="special">;</span> +<span class="special">};</span> + +<span class="keyword">template</span> <span class="special"><</span> <span class="keyword">typename</span> <span class="identifier">Rhs</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">Ret</span> <span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">operator_returns_Ret</span> <span class="special"><</span> <span class="identifier">Rhs</span><span class="special">,</span> <span class="identifier">Ret</span><span class="special">,</span> <span class="keyword">true</span> <span class="special">></span> <span class="special">{</span> + <span class="keyword">static</span> <span class="keyword">const</span> <span class="keyword">bool</span> <span class="identifier">value</span> <span class="special">=</span> <span class="keyword">false</span><span class="special">;</span> +<span class="special">};</span> + +<span class="comment">// otherwise checks if it is convertible to Ret using the sizeof trick</span> +<span class="comment">// based on overload resolution</span> +<span class="comment">// condition: Ret!=void and Ret!=dont_care and the operator does not return void</span> +<span class="keyword">template</span> <span class="special"><</span> <span class="keyword">typename</span> <span class="identifier">Rhs</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">Ret</span> <span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">operator_returns_Ret</span> <span class="special"><</span> <span class="identifier">Rhs</span><span class="special">,</span> <span class="identifier">Ret</span><span class="special">,</span> <span class="keyword">false</span> <span class="special">></span> <span class="special">{</span> + <span class="keyword">static</span> <span class="special">::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">type_traits</span><span class="special">::</span><span class="identifier">yes_type</span> <span class="identifier">is_convertible_to_Ret</span><span class="special">(</span><span class="identifier">Ret</span><span class="special">);</span> <span class="comment">// this version is preferred for types convertible to Ret</span> + <span class="keyword">static</span> <span class="special">::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">type_traits</span><span class="special">::</span><span class="identifier">no_type</span> <span class="identifier">is_convertible_to_Ret</span><span class="special">(...);</span> <span class="comment">// this version is used otherwise</span> + + <span class="keyword">static</span> <span class="keyword">const</span> <span class="keyword">bool</span> <span class="identifier">value</span> <span class="special">=</span> <span class="keyword">sizeof</span><span class="special">(</span><span class="identifier">is_convertible_to_Ret</span><span class="special">(-</span><span class="identifier">make</span><span class="special"><</span><span class="identifier">Rhs</span><span class="special">>()))==</span><span class="keyword">sizeof</span><span class="special">(::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">type_traits</span><span class="special">::</span><span class="identifier">yes_type</span><span class="special">);</span> +<span class="special">};</span> + + +<span class="comment">// 5. checks for operator existence</span> +<span class="comment">// condition: Rhs!=void</span> + +<span class="comment">// checks if our definition of operator- is used or an other</span> +<span class="comment">// existing one;</span> +<span class="comment">// this is done with redefinition of "operator," that returns no_operator or has_operator</span> +<span class="keyword">struct</span> <span class="identifier">has_operator</span> <span class="special">{</span> <span class="special">};</span> +<span class="identifier">no_operator</span> <span class="keyword">operator</span><span class="special">,(</span><span class="identifier">no_operator</span><span class="special">,</span> <span class="identifier">has_operator</span><span class="special">);</span> + +<span class="keyword">template</span> <span class="special"><</span> <span class="keyword">typename</span> <span class="identifier">Rhs</span> <span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">operator_exists</span> <span class="special">{</span> + <span class="keyword">static</span> <span class="special">::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">type_traits</span><span class="special">::</span><span class="identifier">yes_type</span> <span class="identifier">check</span><span class="special">(</span><span class="identifier">has_operator</span><span class="special">);</span> <span class="comment">// this version is preferred when operator exists</span> + <span class="keyword">static</span> <span class="special">::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">type_traits</span><span class="special">::</span><span class="identifier">no_type</span> <span class="identifier">check</span><span class="special">(</span><span class="identifier">no_operator</span><span class="special">);</span> <span class="comment">// this version is used otherwise</span> + + <span class="keyword">static</span> <span class="keyword">const</span> <span class="keyword">bool</span> <span class="identifier">value</span> <span class="special">=</span> <span class="keyword">sizeof</span><span class="special">(</span><span class="identifier">check</span><span class="special">(((-</span><span class="identifier">make</span><span class="special"><</span><span class="identifier">Rhs</span><span class="special">>()),</span><span class="identifier">make</span><span class="special"><</span><span class="identifier">has_operator</span><span class="special">>())))==</span><span class="keyword">sizeof</span><span class="special">(::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">type_traits</span><span class="special">::</span><span class="identifier">yes_type</span><span class="special">);</span> +<span class="special">};</span> + + +<span class="comment">// 6. main trait: to avoid any compilation error, this class behaves</span> +<span class="comment">// differently when operator-(Rhs) is forbidden by the standard.</span> +<span class="comment">// Forbidden_if is a bool that is:</span> +<span class="comment">// - true when the operator-(Rhs) is forbidden by the standard</span> +<span class="comment">// (would yield compilation error if used)</span> +<span class="comment">// - false otherwise</span> +<span class="keyword">template</span> <span class="special"><</span> <span class="keyword">typename</span> <span class="identifier">Rhs</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">Ret</span><span class="special">,</span> <span class="keyword">bool</span> <span class="identifier">Forbidden_if</span> <span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">trait_impl1</span><span class="special">;</span> + +<span class="keyword">template</span> <span class="special"><</span> <span class="keyword">typename</span> <span class="identifier">Rhs</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">Ret</span> <span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">trait_impl1</span> <span class="special"><</span> <span class="identifier">Rhs</span><span class="special">,</span> <span class="identifier">Ret</span><span class="special">,</span> <span class="keyword">true</span> <span class="special">></span> <span class="special">{</span> + <span class="keyword">static</span> <span class="keyword">const</span> <span class="keyword">bool</span> <span class="identifier">value</span> <span class="special">=</span> <span class="keyword">false</span><span class="special">;</span> +<span class="special">};</span> + +<span class="keyword">template</span> <span class="special"><</span> <span class="keyword">typename</span> <span class="identifier">Rhs</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">Ret</span> <span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">trait_impl1</span> <span class="special"><</span> <span class="identifier">Rhs</span><span class="special">,</span> <span class="identifier">Ret</span><span class="special">,</span> <span class="keyword">false</span> <span class="special">></span> <span class="special">{</span> + <span class="keyword">static</span> <span class="keyword">const</span> <span class="keyword">bool</span> <span class="identifier">value</span> <span class="special">=</span> + <span class="special">::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">type_traits</span><span class="special">::</span><span class="identifier">ice_and</span><span class="special"><</span> + <span class="identifier">operator_exists</span> <span class="special"><</span> <span class="identifier">Rhs</span> <span class="special">>::</span><span class="identifier">value</span><span class="special">,</span> + <span class="identifier">operator_returns_Ret</span> <span class="special"><</span> <span class="identifier">Rhs</span><span class="special">,</span> <span class="identifier">Ret</span><span class="special">,</span> <span class="identifier">operator_returns_void</span> <span class="special"><</span> <span class="identifier">Rhs</span> <span class="special">>::</span><span class="identifier">value</span> <span class="special">>::</span><span class="identifier">value</span> + <span class="special">>::</span><span class="identifier">value</span> + <span class="special">;</span> +<span class="special">};</span> + +<span class="comment">// specialization needs to be declared for the special void case</span> +<span class="keyword">template</span> <span class="special"><</span> <span class="keyword">typename</span> <span class="identifier">Ret</span> <span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">trait_impl1</span> <span class="special"><</span> <span class="keyword">void</span><span class="special">,</span> <span class="identifier">Ret</span><span class="special">,</span> <span class="keyword">false</span> <span class="special">></span> <span class="special">{</span> + <span class="keyword">static</span> <span class="keyword">const</span> <span class="keyword">bool</span> <span class="identifier">value</span> <span class="special">=</span> <span class="keyword">false</span><span class="special">;</span> +<span class="special">};</span> + +<span class="comment">// defines some typedef for convenience</span> +<span class="keyword">template</span> <span class="special"><</span> <span class="keyword">typename</span> <span class="identifier">Rhs</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">Ret</span> <span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">trait_impl</span> <span class="special">{</span> + <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="special">::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">remove_reference</span><span class="special"><</span><span class="identifier">Rhs</span><span class="special">>::</span><span class="identifier">type</span> <span class="identifier">Rhs_noref</span><span class="special">;</span> + <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="special">::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">remove_cv</span><span class="special"><</span><span class="identifier">Rhs_noref</span><span class="special">>::</span><span class="identifier">type</span> <span class="identifier">Rhs_nocv</span><span class="special">;</span> + <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="special">::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">remove_cv</span><span class="special"><</span> <span class="keyword">typename</span> <span class="special">::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">remove_reference</span><span class="special"><</span> <span class="keyword">typename</span> <span class="special">::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">remove_pointer</span><span class="special"><</span><span class="identifier">Rhs_noref</span><span class="special">>::</span><span class="identifier">type</span> <span class="special">>::</span><span class="identifier">type</span> <span class="special">>::</span><span class="identifier">type</span> <span class="identifier">Rhs_noptr</span><span class="special">;</span> + <span class="keyword">static</span> <span class="keyword">const</span> <span class="keyword">bool</span> <span class="identifier">value</span> <span class="special">=</span> <span class="identifier">trait_impl1</span> <span class="special"><</span> <span class="identifier">Rhs_noref</span><span class="special">,</span> <span class="identifier">Ret</span><span class="special">,</span> <span class="special">::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">is_pointer</span><span class="special"><</span> <span class="identifier">Rhs_noref</span> <span class="special">>::</span><span class="identifier">value</span> <span class="special">>::</span><span class="identifier">value</span><span class="special">;</span> +<span class="special">};</span> + +<span class="special">}</span> <span class="comment">// namespace impl</span> +<span class="special">}</span> <span class="comment">// namespace detail</span> + +<span class="comment">// this is the accessible definition of the trait to end user</span> +<span class="keyword">template</span> <span class="special"><</span> <span class="keyword">typename</span> <span class="identifier">Rhs</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">Ret</span><span class="special">=::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">detail</span><span class="special">::</span><span class="identifier">has_unary_minus_impl</span><span class="special">::</span><span class="identifier">dont_care</span> <span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">has_unary_minus</span> <span class="special">:</span> <span class="special">::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">integral_constant</span><span class="special"><</span><span class="keyword">bool</span><span class="special">,(::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">detail</span><span class="special">::</span><span class="identifier">has_unary_minus_impl</span><span class="special">::</span><span class="identifier">trait_impl</span> <span class="special"><</span> <span class="identifier">Rhs</span><span class="special">,</span> <span class="identifier">Ret</span> <span class="special">>::</span><span class="identifier">value</span><span class="special">)></span> <span class="special">{</span> <span class="special">};</span> + +<span class="special">}</span> <span class="comment">// namespace boost</span> +</pre> +<p> + </p> +<a name="boost_typetraits.category.value_traits.operators.limitation"></a><h6> +<a name="boost_typetraits.category.value_traits.operators.limitation-heading"></a> + <a class="link" href="operators.html#boost_typetraits.category.value_traits.operators.limitation">Limitation</a> + </h6> +<div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"> + Requires a compiler with working SFINAE. + </li></ul></div> +<a name="boost_typetraits.category.value_traits.operators.known_issues"></a><h6> +<a name="boost_typetraits.category.value_traits.operators.known_issues-heading"></a> + <a class="link" href="operators.html#boost_typetraits.category.value_traits.operators.known_issues">Known + issues</a> + </h6> +<div class="itemizedlist"><ul class="itemizedlist" type="disc"> +<li class="listitem"> + These traits cannot detect whether the operators are public or not: + if an operator is defined as a private member of type <code class="computeroutput"><span class="identifier">T</span></code> then the instantiation of the corresponding + trait will produce a compiler error. For this reason these traits cannot + be used to determine whether a type has a public operator or not. +<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="identifier">A</span> <span class="keyword">operator</span><span class="special">-();</span> <span class="special">};</span> +<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_unary_minus</span><span class="special"><</span><span class="identifier">A</span><span class="special">>::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator-() is private</span> +</pre> + </li> +<li class="listitem"> + There is an issue if the operator exists only for type <code class="computeroutput"><span class="identifier">A</span></code> and <code class="computeroutput"><span class="identifier">B</span></code> + is convertible to <code class="computeroutput"><span class="identifier">A</span></code>. + In this case, the compiler will report an ambiguous overload because + both the existing operator and the one we provide (with argument of + type <code class="computeroutput"><span class="identifier">any</span></code>) need type + conversion, so that none is preferred. +<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span> +<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">-(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&);</span> +<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span> +<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_unary_minus</span><span class="special"><</span><span class="identifier">A</span><span class="special">>::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine</span> +<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_unary_minus</span><span class="special"><</span><span class="identifier">B</span><span class="special">>::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambiguous overload between</span> + <span class="comment">// operator-(const any&) and</span> + <span class="comment">// operator-(const A&)</span> + <span class="comment">// both need type conversion</span> +</pre> + +<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="special">};</span> +<span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="identifier">A</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">B</span><span class="special">&)</span> <span class="special">{</span> <span class="special">}</span> <span class="special">};</span> +<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">-(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&);</span> +<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_unary_minus</span><span class="special"><</span><span class="identifier">A</span><span class="special">>::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine</span> +<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_unary_minus</span><span class="special"><</span><span class="identifier">B</span><span class="special">>::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambiguous overload between</span> + <span class="comment">// operator-(const any&) and</span> + <span class="comment">// operator-(const A&)</span> + <span class="comment">// both need type conversion</span> +</pre> + </li> +<li class="listitem"> + There is an issue when applying these traits to template classes. If + the operator is defined but does not bind for a given template type, + it is still detected by the trait which returns <code class="computeroutput"><span class="keyword">true</span></code> + instead of <code class="computeroutput"><span class="keyword">false</span></code>. This + applies in particular to the containers of the standard library and + <code class="computeroutput"><span class="keyword">operator</span><span class="special">==</span></code>. + Example: +<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_equal_to</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span> +<span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">iostream</span><span class="special">></span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">contains</span> <span class="special">{</span> <span class="identifier">T</span> <span class="identifier">data</span><span class="special">;</span> <span class="special">};</span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">==(</span><span class="keyword">const</span> <span class="identifier">contains</span><span class="special"><</span><span class="identifier">T</span><span class="special">></span> <span class="special">&</span><span class="identifier">lhs</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">contains</span><span class="special"><</span><span class="identifier">T</span><span class="special">></span> <span class="special">&</span><span class="identifier">rhs</span><span class="special">)</span> <span class="special">{</span> + <span class="keyword">return</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">,</span> <span class="identifier">rhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">);</span> +<span class="special">}</span> + +<span class="keyword">class</span> <span class="identifier">bad</span> <span class="special">{</span> <span class="special">};</span> +<span class="keyword">class</span> <span class="identifier">good</span> <span class="special">{</span> <span class="special">};</span> +<span class="keyword">bool</span> <span class="identifier">f</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">good</span><span class="special">&,</span> <span class="keyword">const</span> <span class="identifier">good</span><span class="special">&)</span> <span class="special">{</span> <span class="special">}</span> + +<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span> <span class="special">{</span> + <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special"><<</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">boolalpha</span><span class="special">;</span> + <span class="comment">// works fine for contains<good></span> + <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special"><<</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_equal_to</span><span class="special"><</span> <span class="identifier">contains</span><span class="special"><</span> <span class="identifier">good</span> <span class="special">></span> <span class="special">>::</span><span class="identifier">value</span><span class="special"><<</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true</span> + <span class="identifier">contains</span><span class="special"><</span><span class="identifier">good</span><span class="special">></span> <span class="identifier">g</span><span class="special">;</span> + <span class="identifier">g</span><span class="special">==</span><span class="identifier">g</span><span class="special">;</span> <span class="comment">// ok</span> + <span class="comment">// does not work for contains<bad></span> + <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special"><<</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_equal_to</span><span class="special"><</span> <span class="identifier">contains</span><span class="special"><</span> <span class="identifier">bad</span> <span class="special">></span> <span class="special">>::</span><span class="identifier">value</span><span class="special"><<</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true, should be false</span> + <span class="identifier">contains</span><span class="special"><</span><span class="identifier">bad</span><span class="special">></span> <span class="identifier">b</span><span class="special">;</span> + <span class="identifier">b</span><span class="special">==</span><span class="identifier">b</span><span class="special">;</span> <span class="comment">// compile time error</span> + <span class="keyword">return</span> <span class="number">0</span><span class="special">;</span> +<span class="special">}</span> +</pre> + </li> +<li class="listitem"> + <code class="computeroutput"><span class="keyword">volatile</span></code> qualifier is + not properly handled and would lead to undefined behavior + </li> +</ul></div> +<a name="boost_typetraits.category.value_traits.operators.acknowledgments"></a><h6> +<a name="boost_typetraits.category.value_traits.operators.acknowledgments-heading"></a> + <a class="link" href="operators.html#boost_typetraits.category.value_traits.operators.acknowledgments">Acknowledgments</a> + </h6> +<p> + Frederic Bron is very thankful to numerous people from the boost mailing + list for their kind help and patience. In particular, the following persons + have been very helpful for the implementation: Edward Diener, Eric Niebler, + Jeffrey Lee Hellrung (Jr.), Robert Stewart, Roman Perepelitsa, Steven Watanabe, + Vicente Botet. + </p> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="relate.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../value_traits.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="../transform.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/category/value_traits/primary.html b/libs/type_traits/doc/html/boost_typetraits/category/value_traits/primary.html new file mode 100644 index 0000000000..b57cb427a3 --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/category/value_traits/primary.html @@ -0,0 +1,137 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>Categorizing a Type</title> +<link rel="stylesheet" href="../../../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../../../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../value_traits.html" title="Type Traits that Describe the Properties of a Type"> +<link rel="prev" href="../value_traits.html" title="Type Traits that Describe the Properties of a Type"> +<link rel="next" href="properties.html" title="General Type Properties"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../boost.png"></td> +<td align="center"><a href="../../../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="../value_traits.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../value_traits.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="properties.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h4 class="title"> +<a name="boost_typetraits.category.value_traits.primary"></a><a class="link" href="primary.html" title="Categorizing a Type">Categorizing + a Type</a> +</h4></div></div></div> +<p> + These traits identify what "kind" of type some type <code class="computeroutput"><span class="identifier">T</span></code> 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. + </p> +<p> + For any given type, exactly one primary type trait will inherit from <a class="link" href="../../reference/integral_constant.html" title="integral_constant">true_type</a>, + and all the others will inherit from <a class="link" href="../../reference/integral_constant.html" title="integral_constant">false_type</a>, + in other words these traits are mutually exclusive. + </p> +<p> + This means that <code class="computeroutput"><a class="link" href="../../reference/is_integral.html" title="is_integral">is_integral</a><span class="special"><</span><span class="identifier">T</span><span class="special">>::</span><span class="identifier">value</span></code> + and <code class="computeroutput"><a class="link" href="../../reference/is_floating_point.html" title="is_floating_point">is_floating_point</a><span class="special"><</span><span class="identifier">T</span><span class="special">>::</span><span class="identifier">value</span></code> + 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 <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span> + <span class="keyword">template</span></code> instead. + </p> +<p> + <span class="bold"><strong>Synopsis:</strong></span> + </p> +<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <a class="link" href="../../reference/is_array.html" title="is_array">is_array</a><span class="special">;</span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <a class="link" href="../../reference/is_class.html" title="is_class">is_class</a><span class="special">;</span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <a class="link" href="../../reference/is_complex.html" title="is_complex">is_complex</a><span class="special">;</span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <a class="link" href="../../reference/is_enum.html" title="is_enum">is_enum</a><span class="special">;</span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <a class="link" href="../../reference/is_floating_point.html" title="is_floating_point">is_floating_point</a><span class="special">;</span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <a class="link" href="../../reference/is_function.html" title="is_function">is_function</a><span class="special">;</span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <a class="link" href="../../reference/is_integral.html" title="is_integral">is_integral</a><span class="special">;</span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <a class="link" href="../../reference/is_member_function_pointer.html" title="is_member_function_pointer">is_member_function_pointer</a><span class="special">;</span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <a class="link" href="../../reference/is_member_object_pointer.html" title="is_member_object_pointer">is_member_object_pointer</a><span class="special">;</span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <a class="link" href="../../reference/is_pointer.html" title="is_pointer">is_pointer</a><span class="special">;</span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <a class="link" href="../../reference/is_lvalue_reference.html" title="is_lvalue_reference">is_lvalue_reference</a><span class="special">;</span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <a class="link" href="../../reference/is_rvalue_reference.html" title="is_rvalue_reference">is_rvalue_reference</a><span class="special">;</span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <a class="link" href="../../reference/is_union.html" title="is_union">is_union</a><span class="special">;</span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <a class="link" href="../../reference/is_void.html" title="is_void">is_void</a><span class="special">;</span> +</pre> +<p> + 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. + </p> +<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <a class="link" href="../../reference/is_arithmetic.html" title="is_arithmetic">is_arithmetic</a><span class="special">;</span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <a class="link" href="../../reference/is_compound.html" title="is_compound">is_compound</a><span class="special">;</span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <a class="link" href="../../reference/is_fundamental.html" title="is_fundamental">is_fundamental</a><span class="special">;</span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <a class="link" href="../../reference/is_member_pointer.html" title="is_member_pointer">is_member_pointer</a><span class="special">;</span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <a class="link" href="../../reference/is_object.html" title="is_object">is_object</a><span class="special">;</span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <a class="link" href="../../reference/is_reference.html" title="is_reference">is_reference</a><span class="special">;</span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <a class="link" href="../../reference/is_scalar.html" title="is_scalar">is_scalar</a><span class="special">;</span> +</pre> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="../value_traits.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../value_traits.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="properties.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/category/value_traits/properties.html b/libs/type_traits/doc/html/boost_typetraits/category/value_traits/properties.html new file mode 100644 index 0000000000..e70748da5e --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/category/value_traits/properties.html @@ -0,0 +1,129 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>General Type Properties</title> +<link rel="stylesheet" href="../../../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../../../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../value_traits.html" title="Type Traits that Describe the Properties of a Type"> +<link rel="prev" href="primary.html" title="Categorizing a Type"> +<link rel="next" href="relate.html" title="Relationships Between Two Types"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../boost.png"></td> +<td align="center"><a href="../../../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="primary.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../value_traits.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="relate.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h4 class="title"> +<a name="boost_typetraits.category.value_traits.properties"></a><a class="link" href="properties.html" title="General Type Properties">General + Type Properties</a> +</h4></div></div></div> +<p> + The following templates describe the general properties of a type. + </p> +<p> + <span class="bold"><strong>Synopsis:</strong></span> + </p> +<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <a class="link" href="../../reference/alignment_of.html" title="alignment_of">alignment_of</a><span class="special">;</span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <a class="link" href="../../reference/has_new_operator.html" title="has_new_operator">has_new_operator</a><span class="special">;</span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <a class="link" href="../../reference/has_nothrow_assign.html" title="has_nothrow_assign">has_nothrow_assign</a><span class="special">;</span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <a class="link" href="../../reference/has_nothrow_constructor.html" title="has_nothrow_constructor">has_nothrow_constructor</a><span class="special">;</span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <a class="link" href="../../reference/has_nothrow_constructor.html" title="has_nothrow_constructor">has_nothrow_default_constructor</a><span class="special">;</span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <a class="link" href="../../reference/has_nothrow_copy.html" title="has_nothrow_copy">has_nothrow_copy</a><span class="special">;</span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <a class="link" href="../../reference/has_nothrow_copy.html" title="has_nothrow_copy">has_nothrow_copy_constructor</a><span class="special">;</span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <a class="link" href="../../reference/has_trivial_assign.html" title="has_trivial_assign">has_trivial_assign</a><span class="special">;</span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <a class="link" href="../../reference/has_trivial_constructor.html" title="has_trivial_constructor">has_trivial_constructor</a><span class="special">;</span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <a class="link" href="../../reference/has_trivial_constructor.html" title="has_trivial_constructor">has_trivial_default_constructor</a><span class="special">;</span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <a class="link" href="../../reference/has_trivial_copy.html" title="has_trivial_copy">has_trivial_copy</a><span class="special">;</span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <a class="link" href="../../reference/has_trivial_copy.html" title="has_trivial_copy">has_trivial_copy_constructor</a><span class="special">;</span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <a class="link" href="../../reference/has_trivial_destructor.html" title="has_trivial_destructor">has_trivial_destructor</a><span class="special">;</span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <a class="link" href="../../reference/has_virtual_destructor.html" title="has_virtual_destructor">has_virtual_destructor</a><span class="special">;</span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <a class="link" href="../../reference/is_abstract.html" title="is_abstract">is_abstract</a><span class="special">;</span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <a class="link" href="../../reference/is_const.html" title="is_const">is_const</a><span class="special">;</span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <a class="link" href="../../reference/is_empty.html" title="is_empty">is_empty</a><span class="special">;</span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <a class="link" href="../../reference/is_stateless.html" title="is_stateless">is_stateless</a><span class="special">;</span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <a class="link" href="../../reference/is_pod.html" title="is_pod">is_pod</a><span class="special">;</span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <a class="link" href="../../reference/is_polymorphic.html" title="is_polymorphic">is_polymorphic</a><span class="special">;</span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <a class="link" href="../../reference/is_signed.html" title="is_signed">is_signed</a><span class="special">;</span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <a class="link" href="../../reference/is_unsigned.html" title="is_unsigned">is_unsigned</a><span class="special">;</span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <a class="link" href="../../reference/is_volatile.html" title="is_volatile">is_volatile</a><span class="special">;</span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">N</span> <span class="special">=</span> <span class="number">0</span><span class="special">></span> +<span class="keyword">struct</span> <a class="link" href="../../reference/extent.html" title="extent">extent</a><span class="special">;</span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <a class="link" href="../../reference/rank.html" title="rank">rank</a><span class="special">;</span> +</pre> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="primary.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../value_traits.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="relate.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/category/value_traits/relate.html b/libs/type_traits/doc/html/boost_typetraits/category/value_traits/relate.html new file mode 100644 index 0000000000..93d8328799 --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/category/value_traits/relate.html @@ -0,0 +1,67 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>Relationships Between Two Types</title> +<link rel="stylesheet" href="../../../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../../../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../value_traits.html" title="Type Traits that Describe the Properties of a Type"> +<link rel="prev" href="properties.html" title="General Type Properties"> +<link rel="next" href="operators.html" title="Operator Type Traits"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../boost.png"></td> +<td align="center"><a href="../../../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="properties.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../value_traits.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="operators.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h4 class="title"> +<a name="boost_typetraits.category.value_traits.relate"></a><a class="link" href="relate.html" title="Relationships Between Two Types">Relationships + Between Two Types</a> +</h4></div></div></div> +<p> + These templates determine the whether there is a relationship between two + types: + </p> +<p> + <span class="bold"><strong>Synopsis:</strong></span> + </p> +<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">Base</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Derived</span><span class="special">></span> +<span class="keyword">struct</span> <a class="link" href="../../reference/is_base_of.html" title="is_base_of">is_base_of</a><span class="special">;</span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">Base</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Derived</span><span class="special">></span> +<span class="keyword">struct</span> <a class="link" href="../../reference/is_virtual_base_of.html" title="is_virtual_base_of">is_virtual_base_of</a><span class="special">;</span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">From</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">To</span><span class="special">></span> +<span class="keyword">struct</span> <a class="link" href="../../reference/is_convertible.html" title="is_convertible">is_convertible</a><span class="special">;</span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">U</span><span class="special">></span> +<span class="keyword">struct</span> <a class="link" href="../../reference/is_same.html" title="is_same">is_same</a><span class="special">;</span> +</pre> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="properties.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../value_traits.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="operators.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/credits.html b/libs/type_traits/doc/html/boost_typetraits/credits.html new file mode 100644 index 0000000000..7695780c73 --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/credits.html @@ -0,0 +1,80 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>Credits</title> +<link rel="stylesheet" href="../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="prev" href="history.html" title="History"> +<link rel="next" href="../index/s11.html" title="Class Index"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../boost.png"></td> +<td align="center"><a href="../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="history.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="../index/s11.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h2 class="title" style="clear: both"> +<a name="boost_typetraits.credits"></a><a class="link" href="credits.html" title="Credits">Credits</a> +</h2></div></div></div> +<p> + This documentation was pulled together by John Maddock, using <a href="../../../../../doc/html/quickbook.html" target="_top">Boost.Quickbook</a> + and <a href="../../../../../doc/html/boostbook.html" target="_top">Boost.DocBook</a>. + </p> +<p> + 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. + </p> +<p> + 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. + </p> +<p> + Mat Marcus and Jesse Jones invented, and <a href="http://opensource.adobe.com/project4/project.shtml" target="_top">published + a paper describing</a>, the partial specialization workarounds used in + this library. + </p> +<p> + Aleksey Gurtovoy added MPL integration to the library. + </p> +<p> + The <a class="link" href="reference/is_convertible.html" title="is_convertible">is_convertible</a> + template is based on code originally devised by Andrei Alexandrescu, see "<a href="http://www.cuj.com/experts/1810/alexandr.htm?topic=experts" target="_top">Generic<Programming>: + Mappings between Types and Values</a>". + </p> +<p> + The latest version of this library and documentation can be found at <a href="http://www.boost.org" target="_top">www.boost.org</a>. Bugs, suggestions and discussion + should be directed to boost@lists.boost.org (see <a href="http://www.boost.org/more/mailing_lists.htm#main" target="_top">www.boost.org/more/mailing_lists.htm#main</a> + for subscription details). + </p> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="history.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="../index/s11.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/examples.html b/libs/type_traits/doc/html/boost_typetraits/examples.html new file mode 100644 index 0000000000..9d96e46b16 --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/examples.html @@ -0,0 +1,61 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>Examples</title> +<link rel="stylesheet" href="../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="prev" href="mpl.html" title="MPL Interoperability"> +<link rel="next" href="examples/copy.html" title="An Optimized Version of std::copy"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../boost.png"></td> +<td align="center"><a href="../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="mpl.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="examples/copy.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h2 class="title" style="clear: both"> +<a name="boost_typetraits.examples"></a><a class="link" href="examples.html" title="Examples">Examples</a> +</h2></div></div></div> +<div class="toc"><dl> +<dt><span class="section"><a href="examples/copy.html">An Optimized Version + of std::copy</a></span></dt> +<dt><span class="section"><a href="examples/fill.html">An Optimised Version + of std::fill</a></span></dt> +<dt><span class="section"><a href="examples/destruct.html">An Example that Omits + Destructor Calls For Types with Trivial Destructors</a></span></dt> +<dt><span class="section"><a href="examples/iter.html">An improved Version of + std::iter_swap</a></span></dt> +<dt><span class="section"><a href="examples/to_double.html">Convert Numeric + Types and Enums to double</a></span></dt> +<dt><span class="section"><a href="examples/improved_min.html">Improving std::min + with common_type</a></span></dt> +</dl></div> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="mpl.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="examples/copy.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/examples/copy.html b/libs/type_traits/doc/html/boost_typetraits/examples/copy.html new file mode 100644 index 0000000000..ac7f41faac --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/examples/copy.html @@ -0,0 +1,96 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>An Optimized Version of std::copy</title> +<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../examples.html" title="Examples"> +<link rel="prev" href="../examples.html" title="Examples"> +<link rel="next" href="fill.html" title="An Optimised Version of std::fill"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td> +<td align="center"><a href="../../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="../examples.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../examples.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="fill.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h3 class="title"> +<a name="boost_typetraits.examples.copy"></a><a class="link" href="copy.html" title="An Optimized Version of std::copy">An Optimized Version + of std::copy</a> +</h3></div></div></div> +<p> + Demonstrates a version of <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">copy</span></code> + that uses <code class="computeroutput"><a class="link" href="../reference/has_trivial_assign.html" title="has_trivial_assign">has_trivial_assign</a></code> + to determine whether to use <code class="computeroutput"><span class="identifier">memcpy</span></code> + to optimise the copy operation (see <a href="../../../../examples/copy_example.cpp" target="_top">copy_example.cpp</a>): + </p> +<pre class="programlisting"><span class="comment">//</span> +<span class="comment">// opt::copy</span> +<span class="comment">// same semantics as std::copy</span> +<span class="comment">// calls memcpy where appropriate.</span> +<span class="comment">//</span> + +<span class="keyword">namespace</span> <span class="identifier">detail</span><span class="special">{</span> + +<span class="keyword">template</span><span class="special"><</span><span class="keyword">typename</span> <span class="identifier">I1</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">I2</span><span class="special">,</span> <span class="keyword">bool</span> <span class="identifier">b</span><span class="special">></span> +<span class="identifier">I2</span> <span class="identifier">copy_imp</span><span class="special">(</span><span class="identifier">I1</span> <span class="identifier">first</span><span class="special">,</span> <span class="identifier">I1</span> <span class="identifier">last</span><span class="special">,</span> <span class="identifier">I2</span> <span class="identifier">out</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">boost</span><span class="special">::</span><a class="link" href="../reference/integral_constant.html" title="integral_constant">integral_constant</a><span class="special"><</span><span class="keyword">bool</span><span class="special">,</span> <span class="identifier">b</span><span class="special">>&)</span> +<span class="special">{</span> + <span class="keyword">while</span><span class="special">(</span><span class="identifier">first</span> <span class="special">!=</span> <span class="identifier">last</span><span class="special">)</span> + <span class="special">{</span> + <span class="special">*</span><span class="identifier">out</span> <span class="special">=</span> <span class="special">*</span><span class="identifier">first</span><span class="special">;</span> + <span class="special">++</span><span class="identifier">out</span><span class="special">;</span> + <span class="special">++</span><span class="identifier">first</span><span class="special">;</span> + <span class="special">}</span> + <span class="keyword">return</span> <span class="identifier">out</span><span class="special">;</span> +<span class="special">}</span> + +<span class="keyword">template</span><span class="special"><</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">></span> +<span class="identifier">T</span><span class="special">*</span> <span class="identifier">copy_imp</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">T</span><span class="special">*</span> <span class="identifier">first</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">T</span><span class="special">*</span> <span class="identifier">last</span><span class="special">,</span> <span class="identifier">T</span><span class="special">*</span> <span class="identifier">out</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">boost</span><span class="special">::</span><a class="link" href="../reference/integral_constant.html" title="integral_constant">true_type</a><span class="special">&)</span> +<span class="special">{</span> + <span class="identifier">memmove</span><span class="special">(</span><span class="identifier">out</span><span class="special">,</span> <span class="identifier">first</span><span class="special">,</span> <span class="special">(</span><span class="identifier">last</span><span class="special">-</span><span class="identifier">first</span><span class="special">)*</span><span class="keyword">sizeof</span><span class="special">(</span><span class="identifier">T</span><span class="special">));</span> + <span class="keyword">return</span> <span class="identifier">out</span><span class="special">+(</span><span class="identifier">last</span><span class="special">-</span><span class="identifier">first</span><span class="special">);</span> +<span class="special">}</span> + + +<span class="special">}</span> + +<span class="keyword">template</span><span class="special"><</span><span class="keyword">typename</span> <span class="identifier">I1</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">I2</span><span class="special">></span> +<span class="keyword">inline</span> <span class="identifier">I2</span> <span class="identifier">copy</span><span class="special">(</span><span class="identifier">I1</span> <span class="identifier">first</span><span class="special">,</span> <span class="identifier">I1</span> <span class="identifier">last</span><span class="special">,</span> <span class="identifier">I2</span> <span class="identifier">out</span><span class="special">)</span> +<span class="special">{</span> + <span class="comment">//</span> + <span class="comment">// We can copy with memcpy if T has a trivial assignment operator,</span> + <span class="comment">// and if the iterator arguments are actually pointers (this last</span> + <span class="comment">// requirement we detect with overload resolution):</span> + <span class="comment">//</span> + <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">iterator_traits</span><span class="special"><</span><span class="identifier">I1</span><span class="special">>::</span><span class="identifier">value_type</span> <span class="identifier">value_type</span><span class="special">;</span> + <span class="keyword">return</span> <span class="identifier">detail</span><span class="special">::</span><span class="identifier">copy_imp</span><span class="special">(</span><span class="identifier">first</span><span class="special">,</span> <span class="identifier">last</span><span class="special">,</span> <span class="identifier">out</span><span class="special">,</span> <span class="identifier">boost</span><span class="special">::</span><a class="link" href="../reference/has_trivial_assign.html" title="has_trivial_assign">has_trivial_assign</a><span class="special"><</span><span class="identifier">value_type</span><span class="special">>());</span> +<span class="special">}</span> +</pre> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="../examples.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../examples.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="fill.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/examples/destruct.html b/libs/type_traits/doc/html/boost_typetraits/examples/destruct.html new file mode 100644 index 0000000000..8e1a14fec0 --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/examples/destruct.html @@ -0,0 +1,83 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>An Example that Omits Destructor Calls For Types with Trivial Destructors</title> +<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../examples.html" title="Examples"> +<link rel="prev" href="fill.html" title="An Optimised Version of std::fill"> +<link rel="next" href="iter.html" title="An improved Version of std::iter_swap"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td> +<td align="center"><a href="../../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="fill.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../examples.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="iter.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h3 class="title"> +<a name="boost_typetraits.examples.destruct"></a><a class="link" href="destruct.html" title="An Example that Omits Destructor Calls For Types with Trivial Destructors">An Example that Omits + Destructor Calls For Types with Trivial Destructors</a> +</h3></div></div></div> +<p> + Demonstrates a simple algorithm that uses <code class="computeroutput"><span class="identifier">__has_trivial_destruct</span></code> + to determine whether to destructors need to be called (see <a href="../../../../examples/trivial_destructor_example.cpp" target="_top">trivial_destructor_example.cpp</a>): + </p> +<pre class="programlisting"><span class="comment">//</span> +<span class="comment">// algorithm destroy_array:</span> +<span class="comment">// The reverse of std::unitialized_copy, takes a block of</span> +<span class="comment">// initialized memory and calls destructors on all objects therein.</span> +<span class="comment">//</span> + +<span class="keyword">namespace</span> <span class="identifier">detail</span><span class="special">{</span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">void</span> <span class="identifier">do_destroy_array</span><span class="special">(</span><span class="identifier">T</span><span class="special">*</span> <span class="identifier">first</span><span class="special">,</span> <span class="identifier">T</span><span class="special">*</span> <span class="identifier">last</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">boost</span><span class="special">::</span><a class="link" href="../reference/integral_constant.html" title="integral_constant">false_type</a><span class="special">&)</span> +<span class="special">{</span> + <span class="keyword">while</span><span class="special">(</span><span class="identifier">first</span> <span class="special">!=</span> <span class="identifier">last</span><span class="special">)</span> + <span class="special">{</span> + <span class="identifier">first</span><span class="special">->~</span><span class="identifier">T</span><span class="special">();</span> + <span class="special">++</span><span class="identifier">first</span><span class="special">;</span> + <span class="special">}</span> +<span class="special">}</span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">inline</span> <span class="keyword">void</span> <span class="identifier">do_destroy_array</span><span class="special">(</span><span class="identifier">T</span><span class="special">*</span> <span class="identifier">first</span><span class="special">,</span> <span class="identifier">T</span><span class="special">*</span> <span class="identifier">last</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">boost</span><span class="special">::</span><a class="link" href="../reference/integral_constant.html" title="integral_constant">true_type</a><span class="special">&)</span> +<span class="special">{</span> +<span class="special">}</span> + +<span class="special">}</span> <span class="comment">// namespace detail</span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">inline</span> <span class="keyword">void</span> <span class="identifier">destroy_array</span><span class="special">(</span><span class="identifier">T</span><span class="special">*</span> <span class="identifier">p1</span><span class="special">,</span> <span class="identifier">T</span><span class="special">*</span> <span class="identifier">p2</span><span class="special">)</span> +<span class="special">{</span> + <span class="identifier">detail</span><span class="special">::</span><span class="identifier">do_destroy_array</span><span class="special">(</span><span class="identifier">p1</span><span class="special">,</span> <span class="identifier">p2</span><span class="special">,</span> <span class="special">::</span><span class="identifier">boost</span><span class="special">::</span><a class="link" href="../reference/has_trivial_destructor.html" title="has_trivial_destructor">has_trivial_destructor</a><span class="special"><</span><span class="identifier">T</span><span class="special">>());</span> +<span class="special">}</span> +</pre> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="fill.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../examples.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="iter.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/examples/fill.html b/libs/type_traits/doc/html/boost_typetraits/examples/fill.html new file mode 100644 index 0000000000..185b1d2a72 --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/examples/fill.html @@ -0,0 +1,90 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>An Optimised Version of std::fill</title> +<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../examples.html" title="Examples"> +<link rel="prev" href="copy.html" title="An Optimized Version of std::copy"> +<link rel="next" href="destruct.html" title="An Example that Omits Destructor Calls For Types with Trivial Destructors"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td> +<td align="center"><a href="../../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="copy.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../examples.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="destruct.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h3 class="title"> +<a name="boost_typetraits.examples.fill"></a><a class="link" href="fill.html" title="An Optimised Version of std::fill">An Optimised Version + of std::fill</a> +</h3></div></div></div> +<p> + Demonstrates a version of <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">fill</span></code> + that uses <code class="computeroutput"><a class="link" href="../reference/has_trivial_assign.html" title="has_trivial_assign">has_trivial_assign</a></code> + to determine whether to use <code class="computeroutput"><span class="identifier">memset</span></code> + to optimise the fill operation (see <a href="../../../../examples/fill_example.cpp" target="_top">fill_example.cpp</a>): + </p> +<pre class="programlisting"><span class="comment">//</span> +<span class="comment">// fill</span> +<span class="comment">// same as std::fill, but uses memset where appropriate</span> +<span class="comment">//</span> +<span class="keyword">namespace</span> <span class="identifier">detail</span><span class="special">{</span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">typename</span> <span class="identifier">I</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">bool</span> <span class="identifier">b</span><span class="special">></span> +<span class="keyword">void</span> <span class="identifier">do_fill</span><span class="special">(</span><span class="identifier">I</span> <span class="identifier">first</span><span class="special">,</span> <span class="identifier">I</span> <span class="identifier">last</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">T</span><span class="special">&</span> <span class="identifier">val</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">boost</span><span class="special">::</span><a class="link" href="../reference/integral_constant.html" title="integral_constant">integral_constant</a><span class="special"><</span><span class="keyword">bool</span><span class="special">,</span> <span class="identifier">b</span><span class="special">>&)</span> +<span class="special">{</span> + <span class="keyword">while</span><span class="special">(</span><span class="identifier">first</span> <span class="special">!=</span> <span class="identifier">last</span><span class="special">)</span> + <span class="special">{</span> + <span class="special">*</span><span class="identifier">first</span> <span class="special">=</span> <span class="identifier">val</span><span class="special">;</span> + <span class="special">++</span><span class="identifier">first</span><span class="special">;</span> + <span class="special">}</span> +<span class="special">}</span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">void</span> <span class="identifier">do_fill</span><span class="special">(</span><span class="identifier">T</span><span class="special">*</span> <span class="identifier">first</span><span class="special">,</span> <span class="identifier">T</span><span class="special">*</span> <span class="identifier">last</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">T</span><span class="special">&</span> <span class="identifier">val</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">boost</span><span class="special">::</span><a class="link" href="../reference/integral_constant.html" title="integral_constant">true_type</a><span class="special">&)</span> +<span class="special">{</span> + <span class="identifier">std</span><span class="special">::</span><span class="identifier">memset</span><span class="special">(</span><span class="identifier">first</span><span class="special">,</span> <span class="identifier">val</span><span class="special">,</span> <span class="identifier">last</span><span class="special">-</span><span class="identifier">first</span><span class="special">);</span> +<span class="special">}</span> + +<span class="special">}</span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">I</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">inline</span> <span class="keyword">void</span> <span class="identifier">fill</span><span class="special">(</span><span class="identifier">I</span> <span class="identifier">first</span><span class="special">,</span> <span class="identifier">I</span> <span class="identifier">last</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">T</span><span class="special">&</span> <span class="identifier">val</span><span class="special">)</span> +<span class="special">{</span> + <span class="comment">//</span> + <span class="comment">// We can do an optimised fill if T has a trivial assignment </span> + <span class="comment">// operator and if it's size is one:</span> + <span class="comment">//</span> + <span class="keyword">typedef</span> <span class="identifier">boost</span><span class="special">::</span><a class="link" href="../reference/integral_constant.html" title="integral_constant">integral_constant</a><span class="special"><</span><span class="keyword">bool</span><span class="special">,</span> + <span class="special">::</span><span class="identifier">boost</span><span class="special">::</span><a class="link" href="../reference/has_trivial_assign.html" title="has_trivial_assign">has_trivial_assign</a><span class="special"><</span><span class="identifier">T</span><span class="special">>::</span><span class="identifier">value</span> <span class="special">&&</span> <span class="special">(</span><span class="keyword">sizeof</span><span class="special">(</span><span class="identifier">T</span><span class="special">)</span> <span class="special">==</span> <span class="number">1</span><span class="special">)></span> <span class="identifier">truth_type</span><span class="special">;</span> + <span class="identifier">detail</span><span class="special">::</span><span class="identifier">do_fill</span><span class="special">(</span><span class="identifier">first</span><span class="special">,</span> <span class="identifier">last</span><span class="special">,</span> <span class="identifier">val</span><span class="special">,</span> <span class="identifier">truth_type</span><span class="special">());</span> +<span class="special">}</span> +</pre> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="copy.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../examples.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="destruct.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/examples/improved_min.html b/libs/type_traits/doc/html/boost_typetraits/examples/improved_min.html new file mode 100644 index 0000000000..b246b9a2e7 --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/examples/improved_min.html @@ -0,0 +1,65 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>Improving std::min with common_type</title> +<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../examples.html" title="Examples"> +<link rel="prev" href="to_double.html" title="Convert Numeric Types and Enums to double"> +<link rel="next" href="../reference.html" title="Alphabetical Reference"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td> +<td align="center"><a href="../../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="to_double.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../examples.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="../reference.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h3 class="title"> +<a name="boost_typetraits.examples.improved_min"></a><a class="link" href="improved_min.html" title="Improving std::min with common_type">Improving std::min + with common_type</a> +</h3></div></div></div> +<p> + An improved <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">min</span></code> function could be written like this: + </p> +<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">U</span><span class="special">></span> +<span class="keyword">typename</span> <a class="link" href="../reference/common_type.html" title="common_type">common_type</a><span class="special"><</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">U</span><span class="special">>::</span><span class="identifier">type</span> <span class="identifier">min</span><span class="special">(</span><span class="identifier">T</span> <span class="identifier">t</span><span class="special">,</span> <span class="identifier">T</span> <span class="identifier">u</span><span class="special">)</span> +<span class="special">{</span> + <span class="keyword">return</span> <span class="identifier">t</span> <span class="special"><</span> <span class="identifier">u</span> <span class="special">?</span> <span class="identifier">t</span> <span class="special">:</span> <span class="identifier">u</span><span class="special">;</span> +<span class="special">}</span> +</pre> +<p> + And now expressions such as: + </p> +<pre class="programlisting"><span class="identifier">min</span><span class="special">(</span><span class="number">1</span><span class="special">,</span> <span class="number">2.0</span><span class="special">)</span> +</pre> +<p> + will actually compile and return the correct type! + </p> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="to_double.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../examples.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="../reference.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/examples/iter.html b/libs/type_traits/doc/html/boost_typetraits/examples/iter.html new file mode 100644 index 0000000000..f7d6440792 --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/examples/iter.html @@ -0,0 +1,99 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>An improved Version of std::iter_swap</title> +<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../examples.html" title="Examples"> +<link rel="prev" href="destruct.html" title="An Example that Omits Destructor Calls For Types with Trivial Destructors"> +<link rel="next" href="to_double.html" title="Convert Numeric Types and Enums to double"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td> +<td align="center"><a href="../../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="destruct.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../examples.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="to_double.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h3 class="title"> +<a name="boost_typetraits.examples.iter"></a><a class="link" href="iter.html" title="An improved Version of std::iter_swap">An improved Version of + std::iter_swap</a> +</h3></div></div></div> +<p> + Demonstrates a version of <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">iter_swap</span></code> + 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 <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">swap</span></code> + of it's dereferenced arguments (the same as <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">iter_swap</span></code> + 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 <a href="../../../../examples/iter_swap_example.cpp" target="_top">iter_swap_example.cpp</a>): + </p> +<pre class="programlisting"><span class="comment">//</span> +<span class="comment">// iter_swap:</span> +<span class="comment">// tests whether iterator is a proxying iterator or not, and</span> +<span class="comment">// uses optimal form accordingly:</span> +<span class="comment">//</span> +<span class="keyword">namespace</span> <span class="identifier">detail</span><span class="special">{</span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">typename</span> <span class="identifier">I</span><span class="special">></span> +<span class="keyword">static</span> <span class="keyword">void</span> <span class="identifier">do_swap</span><span class="special">(</span><span class="identifier">I</span> <span class="identifier">one</span><span class="special">,</span> <span class="identifier">I</span> <span class="identifier">two</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">boost</span><span class="special">::</span><a class="link" href="../reference/integral_constant.html" title="integral_constant">false_type</a><span class="special">&)</span> +<span class="special">{</span> + <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">iterator_traits</span><span class="special"><</span><span class="identifier">I</span><span class="special">>::</span><span class="identifier">value_type</span> <span class="identifier">v_t</span><span class="special">;</span> + <span class="identifier">v_t</span> <span class="identifier">v</span> <span class="special">=</span> <span class="special">*</span><span class="identifier">one</span><span class="special">;</span> + <span class="special">*</span><span class="identifier">one</span> <span class="special">=</span> <span class="special">*</span><span class="identifier">two</span><span class="special">;</span> + <span class="special">*</span><span class="identifier">two</span> <span class="special">=</span> <span class="identifier">v</span><span class="special">;</span> +<span class="special">}</span> +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">typename</span> <span class="identifier">I</span><span class="special">></span> +<span class="keyword">static</span> <span class="keyword">void</span> <span class="identifier">do_swap</span><span class="special">(</span><span class="identifier">I</span> <span class="identifier">one</span><span class="special">,</span> <span class="identifier">I</span> <span class="identifier">two</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">boost</span><span class="special">::</span><a class="link" href="../reference/integral_constant.html" title="integral_constant">true_type</a><span class="special">&)</span> +<span class="special">{</span> + <span class="keyword">using</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">swap</span><span class="special">;</span> + <span class="identifier">swap</span><span class="special">(*</span><span class="identifier">one</span><span class="special">,</span> <span class="special">*</span><span class="identifier">two</span><span class="special">);</span> +<span class="special">}</span> + +<span class="special">}</span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">typename</span> <span class="identifier">I1</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">I2</span><span class="special">></span> +<span class="keyword">inline</span> <span class="keyword">void</span> <span class="identifier">iter_swap</span><span class="special">(</span><span class="identifier">I1</span> <span class="identifier">one</span><span class="special">,</span> <span class="identifier">I2</span> <span class="identifier">two</span><span class="special">)</span> +<span class="special">{</span> + <span class="comment">//</span> + <span class="comment">// See is both arguments are non-proxying iterators, </span> + <span class="comment">// and if both iterator the same type:</span> + <span class="comment">//</span> + <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">iterator_traits</span><span class="special"><</span><span class="identifier">I1</span><span class="special">>::</span><span class="identifier">reference</span> <span class="identifier">r1_t</span><span class="special">;</span> + <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">iterator_traits</span><span class="special"><</span><span class="identifier">I2</span><span class="special">>::</span><span class="identifier">reference</span> <span class="identifier">r2_t</span><span class="special">;</span> + + <span class="keyword">typedef</span> <span class="identifier">boost</span><span class="special">::</span><a class="link" href="../reference/integral_constant.html" title="integral_constant">integral_constant</a><span class="special"><</span><span class="keyword">bool</span><span class="special">,</span> + <span class="special">::</span><span class="identifier">boost</span><span class="special">::</span><a class="link" href="../reference/is_reference.html" title="is_reference">is_reference</a><span class="special"><</span><span class="identifier">r1_t</span><span class="special">>::</span><span class="identifier">value</span> + <span class="special">&&</span> <span class="special">::</span><span class="identifier">boost</span><span class="special">::</span><a class="link" href="../reference/is_reference.html" title="is_reference">is_reference</a><span class="special"><</span><span class="identifier">r2_t</span><span class="special">>::</span><span class="identifier">value</span> + <span class="special">&&</span> <span class="special">::</span><span class="identifier">boost</span><span class="special">::</span><a class="link" href="../reference/is_same.html" title="is_same">is_same</a><span class="special"><</span><span class="identifier">r1_t</span><span class="special">,</span> <span class="identifier">r2_t</span><span class="special">>::</span><span class="identifier">value</span><span class="special">></span> <span class="identifier">truth_type</span><span class="special">;</span> + + <span class="identifier">detail</span><span class="special">::</span><span class="identifier">do_swap</span><span class="special">(</span><span class="identifier">one</span><span class="special">,</span> <span class="identifier">two</span><span class="special">,</span> <span class="identifier">truth_type</span><span class="special">());</span> +<span class="special">}</span> +</pre> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="destruct.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../examples.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="to_double.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/examples/to_double.html b/libs/type_traits/doc/html/boost_typetraits/examples/to_double.html new file mode 100644 index 0000000000..a798db6d25 --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/examples/to_double.html @@ -0,0 +1,59 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>Convert Numeric Types and Enums to double</title> +<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../examples.html" title="Examples"> +<link rel="prev" href="iter.html" title="An improved Version of std::iter_swap"> +<link rel="next" href="improved_min.html" title="Improving std::min with common_type"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td> +<td align="center"><a href="../../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="iter.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../examples.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="improved_min.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h3 class="title"> +<a name="boost_typetraits.examples.to_double"></a><a class="link" href="to_double.html" title="Convert Numeric Types and Enums to double">Convert Numeric + Types and Enums to double</a> +</h3></div></div></div> +<p> + Demonstrates a conversion of <a href="../../../../../../libs/numeric/conversion/doc/html/boost_numericconversion/definitions.html#boost_numericconversion.definitions.numeric_types" target="_top">Numeric + Types</a> and enum types to double: + </p> +<pre class="programlisting"><span class="keyword">template</span><span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">inline</span> <span class="keyword">double</span> <span class="identifier">to_double</span><span class="special">(</span><span class="identifier">T</span> <span class="keyword">const</span><span class="special">&</span> <span class="identifier">value</span><span class="special">)</span> +<span class="special">{</span> + <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">promote</span><span class="special"><</span><span class="identifier">T</span><span class="special">>::</span><span class="identifier">type</span> <span class="identifier">promoted</span><span class="special">;</span> + <span class="keyword">return</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">numeric</span><span class="special">::</span><span class="identifier">converter</span><span class="special"><</span><span class="keyword">double</span><span class="special">,</span><span class="identifier">promoted</span><span class="special">>::</span><span class="identifier">convert</span><span class="special">(</span><span class="identifier">value</span><span class="special">);</span> +<span class="special">}</span> +</pre> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="iter.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../examples.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="improved_min.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/history.html b/libs/type_traits/doc/html/boost_typetraits/history.html new file mode 100644 index 0000000000..0567db7321 --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/history.html @@ -0,0 +1,100 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>History</title> +<link rel="stylesheet" href="../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="prev" href="reference/type_with_alignment.html" title="type_with_alignment"> +<link rel="next" href="credits.html" title="Credits"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../boost.png"></td> +<td align="center"><a href="../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="reference/type_with_alignment.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="credits.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h2 class="title" style="clear: both"> +<a name="boost_typetraits.history"></a><a class="link" href="history.html" title="History">History</a> +</h2></div></div></div> +<a name="boost_typetraits.history.boost_1_47_0"></a><h5> +<a name="boost_typetraits.history.boost_1_47_0-heading"></a> + <a class="link" href="history.html#boost_typetraits.history.boost_1_47_0">Boost 1.47.0</a> + </h5> +<div class="itemizedlist"><ul class="itemizedlist" type="disc"> +<li class="listitem"> + <span class="bold"><strong>Breaking change</strong></span>: changed <a class="link" href="reference/is_convertible.html" title="is_convertible">is_convertible</a> + to C++0x behaviour when possible. + </li> +<li class="listitem"> + Fixed issues <a href="https://svn.boost.org/trac/boost/ticket/5271" target="_top">#5271</a>, + <a href="https://svn.boost.org/trac/boost/ticket/4530" target="_top">#4530</a>. + </li> +</ul></div> +<a name="boost_typetraits.history.boost_1_45_0"></a><h5> +<a name="boost_typetraits.history.boost_1_45_0-heading"></a> + <a class="link" href="history.html#boost_typetraits.history.boost_1_45_0">Boost 1.45.0</a> + </h5> +<div class="itemizedlist"><ul class="itemizedlist" type="disc"> +<li class="listitem"> + Added new traits <a class="link" href="reference/add_rvalue_reference.html" title="add_rvalue_reference">add_rvalue_reference</a>, + <a class="link" href="reference/add_lvalue_reference.html" title="add_lvalue_reference">add_lvalue_reference</a> + and <a class="link" href="reference/common_type.html" title="common_type">common_type</a>. + </li> +<li class="listitem"> + Minor fixes to <a class="link" href="reference/is_signed.html" title="is_signed">is_signed</a>, + <a class="link" href="reference/is_unsigned.html" title="is_unsigned">is_unsigned</a> + and <a class="link" href="reference/is_virtual_base_of.html" title="is_virtual_base_of">is_virtual_base_of</a>. + </li> +</ul></div> +<a name="boost_typetraits.history.boost_1_44_0"></a><h5> +<a name="boost_typetraits.history.boost_1_44_0-heading"></a> + <a class="link" href="history.html#boost_typetraits.history.boost_1_44_0">Boost 1.44.0</a> + </h5> +<div class="itemizedlist"><ul class="itemizedlist" type="disc"> +<li class="listitem"> + Added support for rvalue references throughout the library, plus two new + traits classes <a class="link" href="reference/is_rvalue_reference.html" title="is_rvalue_reference">is_rvalue_reference</a> + and <a class="link" href="reference/is_lvalue_reference.html" title="is_lvalue_reference">is_lvalue_reference</a>. + Fixes <a href="https://svn.boost.org/trac/boost/ticket/4407" target="_top">#4407</a> + and <a href="https://svn.boost.org/trac/boost/ticket/3804" target="_top">#3804</a>. + </li> +<li class="listitem"> + Fixed ticket <a href="https://svn.boost.org/trac/boost/ticket/3621" target="_top">#3621</a>. + </li> +</ul></div> +<a name="boost_typetraits.history.boost_1_42_0"></a><h5> +<a name="boost_typetraits.history.boost_1_42_0-heading"></a> + <a class="link" href="history.html#boost_typetraits.history.boost_1_42_0">Boost 1.42.0</a> + </h5> +<div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"> + Fixed issue <a href="https://svn.boost.org/trac/boost/ticket/3704" target="_top">#3704</a>. + </li></ul></div> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="reference/type_with_alignment.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="credits.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/intrinsics.html b/libs/type_traits/doc/html/boost_typetraits/intrinsics.html new file mode 100644 index 0000000000..8429c36cf8 --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/intrinsics.html @@ -0,0 +1,357 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>Support for Compiler Intrinsics</title> +<link rel="stylesheet" href="../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="prev" href="user_defined.html" title="User Defined Specializations"> +<link rel="next" href="mpl.html" title="MPL Interoperability"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../boost.png"></td> +<td align="center"><a href="../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="user_defined.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="mpl.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h2 class="title" style="clear: both"> +<a name="boost_typetraits.intrinsics"></a><a class="link" href="intrinsics.html" title="Support for Compiler Intrinsics">Support for Compiler Intrinsics</a> +</h2></div></div></div> +<p> + 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 (April 2008) Visual + C++ 8 and 9, GNU GCC 4.3 and MWCW 9 provide the necessary intrinsics, and other + compilers will no doubt follow in due course. + </p> +<p> + 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): + </p> +<div class="itemizedlist"><ul class="itemizedlist" type="disc"> +<li class="listitem"> + <a class="link" href="reference/is_union.html" title="is_union">is_union</a> + </li> +<li class="listitem"> + <a class="link" href="reference/is_pod.html" title="is_pod">is_pod</a> + </li> +<li class="listitem"> + <a class="link" href="reference/has_trivial_constructor.html" title="has_trivial_constructor">has_trivial_constructor</a> + </li> +<li class="listitem"> + <a class="link" href="reference/has_trivial_copy.html" title="has_trivial_copy">has_trivial_copy</a> + </li> +<li class="listitem"> + <a class="link" href="reference/has_trivial_assign.html" title="has_trivial_assign">has_trivial_assign</a> + </li> +<li class="listitem"> + <a class="link" href="reference/has_trivial_destructor.html" title="has_trivial_destructor">has_trivial_destructor</a> + </li> +<li class="listitem"> + <a class="link" href="reference/has_nothrow_constructor.html" title="has_nothrow_constructor">has_nothrow_constructor</a> + </li> +<li class="listitem"> + <a class="link" href="reference/has_nothrow_copy.html" title="has_nothrow_copy">has_nothrow_copy</a> + </li> +<li class="listitem"> + <a class="link" href="reference/has_nothrow_assign.html" title="has_nothrow_assign">has_nothrow_assign</a> + </li> +<li class="listitem"> + <a class="link" href="reference/has_virtual_destructor.html" title="has_virtual_destructor">has_virtual_destructor</a> + </li> +</ul></div> +<p> + 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: + </p> +<div class="itemizedlist"><ul class="itemizedlist" type="disc"> +<li class="listitem"> + <a class="link" href="reference/is_empty.html" title="is_empty">is_empty</a> + </li> +<li class="listitem"> + <a class="link" href="reference/is_polymorphic.html" title="is_polymorphic">is_polymorphic</a> + </li> +</ul></div> +<p> + The following traits classes are dependent on one or more of the above: + </p> +<div class="itemizedlist"><ul class="itemizedlist" type="disc"> +<li class="listitem"> + <a class="link" href="reference/is_class.html" title="is_class">is_class</a> + </li> +<li class="listitem"> + <a class="link" href="reference/is_stateless.html" title="is_stateless">is_stateless</a> + </li> +</ul></div> +<p> + The hooks for compiler-intrinsic support are defined in <a href="../../../../../boost/type_traits/intrinsics.hpp" target="_top">boost/type_traits/intrinsics.hpp</a>, + adding support for new compilers is simply a matter of defining one of more + of the following macros: + </p> +<div class="table"> +<a name="boost_typetraits.intrinsics.macros_for_compiler_intrinsics"></a><p class="title"><b>Table 1.9. Macros for Compiler Intrinsics</b></p> +<div class="table-contents"><table class="table" summary="Macros for Compiler Intrinsics"> +<colgroup> +<col> +<col> +</colgroup> +<thead><tr> +<th> + <p> + BOOST_IS_UNION(T) + </p> + </th> +<th> + <p> + Should evaluate to true if T is a union type + </p> + </th> +</tr></thead> +<tbody> +<tr> +<td> + <p> + BOOST_IS_POD(T) + </p> + </td> +<td> + <p> + Should evaluate to true if T is a POD type + </p> + </td> +</tr> +<tr> +<td> + <p> + BOOST_IS_EMPTY(T) + </p> + </td> +<td> + <p> + Should evaluate to true if T is an empty struct or union + </p> + </td> +</tr> +<tr> +<td> + <p> + BOOST_HAS_TRIVIAL_CONSTRUCTOR(T) + </p> + </td> +<td> + <p> + Should evaluate to true if the default constructor for T is trivial + (i.e. has no effect) + </p> + </td> +</tr> +<tr> +<td> + <p> + BOOST_HAS_TRIVIAL_COPY(T) + </p> + </td> +<td> + <p> + Should evaluate to true if T has a trivial copy constructor (and + can therefore be replaced by a call to memcpy) + </p> + </td> +</tr> +<tr> +<td> + <p> + BOOST_HAS_TRIVIAL_ASSIGN(T) + </p> + </td> +<td> + <p> + Should evaluate to true if T has a trivial assignment operator (and + can therefore be replaced by a call to memcpy) + </p> + </td> +</tr> +<tr> +<td> + <p> + BOOST_HAS_TRIVIAL_DESTRUCTOR(T) + </p> + </td> +<td> + <p> + Should evaluate to true if T has a trivial destructor (i.e. ~T() + has no effect) + </p> + </td> +</tr> +<tr> +<td> + <p> + BOOST_HAS_NOTHROW_CONSTRUCTOR(T) + </p> + </td> +<td> + <p> + Should evaluate to true if <code class="computeroutput"><span class="identifier">T</span> + <span class="identifier">x</span><span class="special">;</span></code> + can not throw + </p> + </td> +</tr> +<tr> +<td> + <p> + BOOST_HAS_NOTHROW_COPY(T) + </p> + </td> +<td> + <p> + Should evaluate to true if <code class="computeroutput"><span class="identifier">T</span><span class="special">(</span><span class="identifier">t</span><span class="special">)</span></code> can not throw + </p> + </td> +</tr> +<tr> +<td> + <p> + BOOST_HAS_NOTHROW_ASSIGN(T) + </p> + </td> +<td> + <p> + Should evaluate to true if <code class="computeroutput"><span class="identifier">T</span> + <span class="identifier">t</span><span class="special">,</span> + <span class="identifier">u</span><span class="special">;</span> + <span class="identifier">t</span> <span class="special">=</span> + <span class="identifier">u</span></code> can not throw + </p> + </td> +</tr> +<tr> +<td> + <p> + BOOST_HAS_VIRTUAL_DESTRUCTOR(T) + </p> + </td> +<td> + <p> + Should evaluate to true T has a virtual destructor + </p> + </td> +</tr> +<tr> +<td> + <p> + BOOST_IS_ABSTRACT(T) + </p> + </td> +<td> + <p> + Should evaluate to true if T is an abstract type + </p> + </td> +</tr> +<tr> +<td> + <p> + BOOST_IS_BASE_OF(T,U) + </p> + </td> +<td> + <p> + Should evaluate to true if T is a base class of U + </p> + </td> +</tr> +<tr> +<td> + <p> + BOOST_IS_CLASS(T) + </p> + </td> +<td> + <p> + Should evaluate to true if T is a class type + </p> + </td> +</tr> +<tr> +<td> + <p> + BOOST_IS_CONVERTIBLE(T,U) + </p> + </td> +<td> + <p> + Should evaluate to true if T is convertible to U + </p> + </td> +</tr> +<tr> +<td> + <p> + BOOST_IS_ENUM(T) + </p> + </td> +<td> + <p> + Should evaluate to true is T is an enum + </p> + </td> +</tr> +<tr> +<td> + <p> + BOOST_IS_POLYMORPHIC(T) + </p> + </td> +<td> + <p> + Should evaluate to true if T is a polymorphic type + </p> + </td> +</tr> +<tr> +<td> + <p> + BOOST_ALIGNMENT_OF(T) + </p> + </td> +<td> + <p> + Should evaluate to the alignment requirements of type T. + </p> + </td> +</tr> +</tbody> +</table></div> +</div> +<br class="table-break"> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="user_defined.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="mpl.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/intro.html b/libs/type_traits/doc/html/boost_typetraits/intro.html new file mode 100644 index 0000000000..27e8875fbd --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/intro.html @@ -0,0 +1,66 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>Introduction</title> +<link rel="stylesheet" href="../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="prev" href="../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="next" href="background.html" title="Background and Tutorial"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../boost.png"></td> +<td align="center"><a href="../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="../index.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="background.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h2 class="title" style="clear: both"> +<a name="boost_typetraits.intro"></a><a class="link" href="intro.html" title="Introduction">Introduction</a> +</h2></div></div></div> +<p> + The Boost type-traits library contains 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? + </p> +<p> + The type-traits classes share a unified design: each class inherits from the + type <a class="link" href="reference/integral_constant.html" title="integral_constant">true_type</a> + if the type has the specified property and inherits from <a class="link" href="reference/integral_constant.html" title="integral_constant">false_type</a> + otherwise. + </p> +<p> + 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 <code class="computeroutput"><span class="identifier">type</span></code> + that is the result of the transformation. + </p> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="../index.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="background.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/mpl.html b/libs/type_traits/doc/html/boost_typetraits/mpl.html new file mode 100644 index 0000000000..31b9322ce9 --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/mpl.html @@ -0,0 +1,63 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>MPL Interoperability</title> +<link rel="stylesheet" href="../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="prev" href="intrinsics.html" title="Support for Compiler Intrinsics"> +<link rel="next" href="examples.html" title="Examples"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../boost.png"></td> +<td align="center"><a href="../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="intrinsics.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="examples.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h2 class="title" style="clear: both"> +<a name="boost_typetraits.mpl"></a><a class="link" href="mpl.html" title="MPL Interoperability">MPL Interoperability</a> +</h2></div></div></div> +<p> + All the value based traits in this library conform to MPL's requirements for + an <a href="../../../../../libs/mpl/doc/refmanual/integral-constant.html" target="_top">Integral + Constant type</a>: that includes a number of rather intrusive workarounds + for broken compilers. + </p> +<p> + Purely as an implementation detail, this means that <code class="computeroutput"><a class="link" href="reference/integral_constant.html" title="integral_constant">true_type</a></code> + inherits from <a href="../../../../../libs/mpl/doc/refmanual/bool.html" target="_top"><code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">mpl</span><span class="special">::</span><span class="identifier">true_</span></code></a>, + <code class="computeroutput"><a class="link" href="reference/integral_constant.html" title="integral_constant">false_type</a></code> + inherits from <a href="../../../../../libs/mpl/doc/refmanual/bool.html" target="_top"><code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">mpl</span><span class="special">::</span><span class="identifier">false_</span></code></a>, + and <code class="computeroutput"><a class="link" href="reference/integral_constant.html" title="integral_constant">integral_constant</a><span class="special"><</span><span class="identifier">T</span><span class="special">,</span> + <span class="identifier">v</span><span class="special">></span></code> + inherits from <a href="../../../../../libs/mpl/doc/refmanual/integral-c.html" target="_top"><code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">mpl</span><span class="special">::</span><span class="identifier">integral_c</span><span class="special"><</span><span class="identifier">T</span><span class="special">,</span><span class="identifier">v</span><span class="special">></span></code></a> + (provided <code class="computeroutput"><span class="identifier">T</span></code> is not <code class="computeroutput"><span class="keyword">bool</span></code>) + </p> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="intrinsics.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="examples.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/reference.html b/libs/type_traits/doc/html/boost_typetraits/reference.html new file mode 100644 index 0000000000..f9c7097930 --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/reference.html @@ -0,0 +1,163 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>Alphabetical Reference</title> +<link rel="stylesheet" href="../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="prev" href="examples/improved_min.html" title="Improving std::min with common_type"> +<link rel="next" href="reference/add_const.html" title="add_const"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../boost.png"></td> +<td align="center"><a href="../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="examples/improved_min.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="reference/add_const.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h2 class="title" style="clear: both"> +<a name="boost_typetraits.reference"></a><a class="link" href="reference.html" title="Alphabetical Reference">Alphabetical Reference</a> +</h2></div></div></div> +<div class="toc"><dl> +<dt><span class="section"><a href="reference/add_const.html">add_const</a></span></dt> +<dt><span class="section"><a href="reference/add_cv.html">add_cv</a></span></dt> +<dt><span class="section"><a href="reference/add_lvalue_reference.html">add_lvalue_reference</a></span></dt> +<dt><span class="section"><a href="reference/add_pointer.html">add_pointer</a></span></dt> +<dt><span class="section"><a href="reference/add_reference.html">add_reference</a></span></dt> +<dt><span class="section"><a href="reference/add_rvalue_reference.html">add_rvalue_reference</a></span></dt> +<dt><span class="section"><a href="reference/add_volatile.html">add_volatile</a></span></dt> +<dt><span class="section"><a href="reference/aligned_storage.html">aligned_storage</a></span></dt> +<dt><span class="section"><a href="reference/alignment_of.html">alignment_of</a></span></dt> +<dt><span class="section"><a href="reference/conditional.html">conditional</a></span></dt> +<dt><span class="section"><a href="reference/common_type.html">common_type</a></span></dt> +<dt><span class="section"><a href="reference/decay.html">decay</a></span></dt> +<dt><span class="section"><a href="reference/extent.html">extent</a></span></dt> +<dt><span class="section"><a href="reference/floating_point_promotion.html">floating_point_promotion</a></span></dt> +<dt><span class="section"><a href="reference/function_traits.html">function_traits</a></span></dt> +<dt><span class="section"><a href="reference/has_bit_and.html">has_bit_and</a></span></dt> +<dt><span class="section"><a href="reference/has_bit_and_assign.html">has_bit_and_assign</a></span></dt> +<dt><span class="section"><a href="reference/has_bit_or.html">has_bit_or</a></span></dt> +<dt><span class="section"><a href="reference/has_bit_or_assign.html">has_bit_or_assign</a></span></dt> +<dt><span class="section"><a href="reference/has_bit_xor.html">has_bit_xor</a></span></dt> +<dt><span class="section"><a href="reference/has_bit_xor_assign.html">has_bit_xor_assign</a></span></dt> +<dt><span class="section"><a href="reference/has_complement.html">has_complement</a></span></dt> +<dt><span class="section"><a href="reference/has_dereference.html">has_dereference</a></span></dt> +<dt><span class="section"><a href="reference/has_divides.html">has_divides</a></span></dt> +<dt><span class="section"><a href="reference/has_divides_assign.html">has_divides_assign</a></span></dt> +<dt><span class="section"><a href="reference/has_equal_to.html">has_equal_to</a></span></dt> +<dt><span class="section"><a href="reference/has_greater.html">has_greater</a></span></dt> +<dt><span class="section"><a href="reference/has_greater_equal.html">has_greater_equal</a></span></dt> +<dt><span class="section"><a href="reference/has_left_shift.html">has_left_shift</a></span></dt> +<dt><span class="section"><a href="reference/has_left_shift_assign.html">has_left_shift_assign</a></span></dt> +<dt><span class="section"><a href="reference/has_less.html">has_less</a></span></dt> +<dt><span class="section"><a href="reference/has_less_equal.html">has_less_equal</a></span></dt> +<dt><span class="section"><a href="reference/has_logical_and.html">has_logical_and</a></span></dt> +<dt><span class="section"><a href="reference/has_logical_not.html">has_logical_not</a></span></dt> +<dt><span class="section"><a href="reference/has_logical_or.html">has_logical_or</a></span></dt> +<dt><span class="section"><a href="reference/has_minus.html">has_minus</a></span></dt> +<dt><span class="section"><a href="reference/has_minus_assign.html">has_minus_assign</a></span></dt> +<dt><span class="section"><a href="reference/has_modulus.html">has_modulus</a></span></dt> +<dt><span class="section"><a href="reference/has_modulus_assign.html">has_modulus_assign</a></span></dt> +<dt><span class="section"><a href="reference/has_multiplies.html">has_multiplies</a></span></dt> +<dt><span class="section"><a href="reference/has_multiplies_assign.html">has_multiplies_assign</a></span></dt> +<dt><span class="section"><a href="reference/has_negate.html">has_negate</a></span></dt> +<dt><span class="section"><a href="reference/has_new_operator.html">has_new_operator</a></span></dt> +<dt><span class="section"><a href="reference/has_not_equal_to.html">has_not_equal_to</a></span></dt> +<dt><span class="section"><a href="reference/has_nothrow_assign.html">has_nothrow_assign</a></span></dt> +<dt><span class="section"><a href="reference/has_nothrow_constructor.html">has_nothrow_constructor</a></span></dt> +<dt><span class="section"><a href="reference/has_nothrow_copy.html">has_nothrow_copy</a></span></dt> +<dt><span class="section"><a href="reference/has_nothrow_cp_cons.html">has_nothrow_copy_constructor</a></span></dt> +<dt><span class="section"><a href="reference/has_no_throw_def_cons.html">has_nothrow_default_constructor</a></span></dt> +<dt><span class="section"><a href="reference/has_plus.html">has_plus</a></span></dt> +<dt><span class="section"><a href="reference/has_plus_assign.html">has_plus_assign</a></span></dt> +<dt><span class="section"><a href="reference/has_post_decrement.html">has_post_decrement</a></span></dt> +<dt><span class="section"><a href="reference/has_post_increment.html">has_post_increment</a></span></dt> +<dt><span class="section"><a href="reference/has_pre_decrement.html">has_pre_decrement</a></span></dt> +<dt><span class="section"><a href="reference/has_pre_increment.html">has_pre_increment</a></span></dt> +<dt><span class="section"><a href="reference/has_right_shift.html">has_right_shift</a></span></dt> +<dt><span class="section"><a href="reference/has_right_shift_assign.html">has_right_shift_assign</a></span></dt> +<dt><span class="section"><a href="reference/has_trivial_assign.html">has_trivial_assign</a></span></dt> +<dt><span class="section"><a href="reference/has_trivial_constructor.html">has_trivial_constructor</a></span></dt> +<dt><span class="section"><a href="reference/has_trivial_copy.html">has_trivial_copy</a></span></dt> +<dt><span class="section"><a href="reference/has_trivial_cp_cons.html">has_trivial_copy_constructor</a></span></dt> +<dt><span class="section"><a href="reference/has_trivial_def_cons.html">has_trivial_default_constructor</a></span></dt> +<dt><span class="section"><a href="reference/has_trivial_destructor.html">has_trivial_destructor</a></span></dt> +<dt><span class="section"><a href="reference/has_unary_minus.html">has_unary_minus</a></span></dt> +<dt><span class="section"><a href="reference/has_unary_plus.html">has_unary_plus</a></span></dt> +<dt><span class="section"><a href="reference/has_virtual_destructor.html">has_virtual_destructor</a></span></dt> +<dt><span class="section"><a href="reference/integral_constant.html">integral_constant</a></span></dt> +<dt><span class="section"><a href="reference/integral_promotion.html">integral_promotion</a></span></dt> +<dt><span class="section"><a href="reference/is_abstract.html">is_abstract</a></span></dt> +<dt><span class="section"><a href="reference/is_arithmetic.html">is_arithmetic</a></span></dt> +<dt><span class="section"><a href="reference/is_array.html">is_array</a></span></dt> +<dt><span class="section"><a href="reference/is_base_of.html">is_base_of</a></span></dt> +<dt><span class="section"><a href="reference/is_class.html">is_class</a></span></dt> +<dt><span class="section"><a href="reference/is_complex.html">is_complex</a></span></dt> +<dt><span class="section"><a href="reference/is_compound.html">is_compound</a></span></dt> +<dt><span class="section"><a href="reference/is_const.html">is_const</a></span></dt> +<dt><span class="section"><a href="reference/is_convertible.html">is_convertible</a></span></dt> +<dt><span class="section"><a href="reference/is_empty.html">is_empty</a></span></dt> +<dt><span class="section"><a href="reference/is_enum.html">is_enum</a></span></dt> +<dt><span class="section"><a href="reference/is_floating_point.html">is_floating_point</a></span></dt> +<dt><span class="section"><a href="reference/is_function.html">is_function</a></span></dt> +<dt><span class="section"><a href="reference/is_fundamental.html">is_fundamental</a></span></dt> +<dt><span class="section"><a href="reference/is_integral.html">is_integral</a></span></dt> +<dt><span class="section"><a href="reference/is_lvalue_reference.html">is_lvalue_reference</a></span></dt> +<dt><span class="section"><a href="reference/is_member_function_pointer.html">is_member_function_pointer</a></span></dt> +<dt><span class="section"><a href="reference/is_member_object_pointer.html">is_member_object_pointer</a></span></dt> +<dt><span class="section"><a href="reference/is_member_pointer.html">is_member_pointer</a></span></dt> +<dt><span class="section"><a href="reference/is_object.html">is_object</a></span></dt> +<dt><span class="section"><a href="reference/is_pod.html">is_pod</a></span></dt> +<dt><span class="section"><a href="reference/is_pointer.html">is_pointer</a></span></dt> +<dt><span class="section"><a href="reference/is_polymorphic.html">is_polymorphic</a></span></dt> +<dt><span class="section"><a href="reference/is_reference.html">is_reference</a></span></dt> +<dt><span class="section"><a href="reference/is_rvalue_reference.html">is_rvalue_reference</a></span></dt> +<dt><span class="section"><a href="reference/is_same.html">is_same</a></span></dt> +<dt><span class="section"><a href="reference/is_scalar.html">is_scalar</a></span></dt> +<dt><span class="section"><a href="reference/is_signed.html">is_signed</a></span></dt> +<dt><span class="section"><a href="reference/is_stateless.html">is_stateless</a></span></dt> +<dt><span class="section"><a href="reference/is_union.html">is_union</a></span></dt> +<dt><span class="section"><a href="reference/is_unsigned.html">is_unsigned</a></span></dt> +<dt><span class="section"><a href="reference/is_virtual_base_of.html">is_virtual_base_of</a></span></dt> +<dt><span class="section"><a href="reference/is_void.html">is_void</a></span></dt> +<dt><span class="section"><a href="reference/is_volatile.html">is_volatile</a></span></dt> +<dt><span class="section"><a href="reference/make_signed.html">make_signed</a></span></dt> +<dt><span class="section"><a href="reference/make_unsigned.html">make_unsigned</a></span></dt> +<dt><span class="section"><a href="reference/promote.html">promote</a></span></dt> +<dt><span class="section"><a href="reference/rank.html">rank</a></span></dt> +<dt><span class="section"><a href="reference/remove_all_extents.html">remove_all_extents</a></span></dt> +<dt><span class="section"><a href="reference/remove_const.html">remove_const</a></span></dt> +<dt><span class="section"><a href="reference/remove_cv.html">remove_cv</a></span></dt> +<dt><span class="section"><a href="reference/remove_extent.html">remove_extent</a></span></dt> +<dt><span class="section"><a href="reference/remove_pointer.html">remove_pointer</a></span></dt> +<dt><span class="section"><a href="reference/remove_reference.html">remove_reference</a></span></dt> +<dt><span class="section"><a href="reference/remove_volatile.html">remove_volatile</a></span></dt> +<dt><span class="section"><a href="reference/type_with_alignment.html">type_with_alignment</a></span></dt> +</dl></div> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="examples/improved_min.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="reference/add_const.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/reference/add_const.html b/libs/type_traits/doc/html/boost_typetraits/reference/add_const.html new file mode 100644 index 0000000000..9255f975f0 --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/reference/add_const.html @@ -0,0 +1,146 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>add_const</title> +<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../reference.html" title="Alphabetical Reference"> +<link rel="prev" href="../reference.html" title="Alphabetical Reference"> +<link rel="next" href="add_cv.html" title="add_cv"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td> +<td align="center"><a href="../../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="../reference.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="add_cv.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h3 class="title"> +<a name="boost_typetraits.reference.add_const"></a><a class="link" href="add_const.html" title="add_const">add_const</a> +</h3></div></div></div> +<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">add_const</span> +<span class="special">{</span> + <span class="keyword">typedef</span> <em class="replaceable"><code>see-below</code></em> <span class="identifier">type</span><span class="special">;</span> +<span class="special">};</span> +</pre> +<p> + <span class="bold"><strong>type:</strong></span> The same type as <code class="computeroutput"><span class="identifier">T</span> + <span class="keyword">const</span></code> for all <code class="computeroutput"><span class="identifier">T</span></code>. + </p> +<p> + <span class="bold"><strong>C++ Standard Reference:</strong></span> 3.9.3. + </p> +<p> + <span class="bold"><strong>Compiler Compatibility:</strong></span> If the compiler + does not support partial specialization of class-templates then this template + will compile, but the member <code class="computeroutput"><span class="identifier">type</span></code> + will always be the same as type <code class="computeroutput"><span class="identifier">T</span></code> + except where <a class="link" href="../category/transform.html#boost_typetraits.category.transform.broken_compiler_workarounds_">compiler + workarounds</a> have been applied. + </p> +<p> + <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"> <span class="preprocessor">#include</span> + <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">add_const</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + </p> +<div class="table"> +<a name="boost_typetraits.reference.add_const.examples"></a><p class="title"><b>Table 1.10. Examples</b></p> +<div class="table-contents"><table class="table" summary="Examples"> +<colgroup> +<col> +<col> +</colgroup> +<thead><tr> +<th> + <p> + Expression + </p> + </th> +<th> + <p> + Result Type + </p> + </th> +</tr></thead> +<tbody> +<tr> +<td> + <p> + <code class="computeroutput"><span class="identifier">add_const</span><span class="special"><</span><span class="keyword">int</span><span class="special">>::</span><span class="identifier">type</span></code> + </p> + </td> +<td> + <p> + <code class="computeroutput"><span class="keyword">int</span> <span class="keyword">const</span></code> + </p> + </td> +</tr> +<tr> +<td> + <p> + <code class="computeroutput"><span class="identifier">add_const</span><span class="special"><</span><span class="keyword">int</span><span class="special">&>::</span><span class="identifier">type</span></code> + </p> + </td> +<td> + <p> + <code class="computeroutput"><span class="keyword">int</span><span class="special">&</span></code> + </p> + </td> +</tr> +<tr> +<td> + <p> + <code class="computeroutput"><span class="identifier">add_const</span><span class="special"><</span><span class="keyword">int</span><span class="special">*>::</span><span class="identifier">type</span></code> + </p> + </td> +<td> + <p> + <code class="computeroutput"><span class="keyword">int</span><span class="special">*</span> + <span class="keyword">const</span></code> + </p> + </td> +</tr> +<tr> +<td> + <p> + <code class="computeroutput"><span class="identifier">add_const</span><span class="special"><</span><span class="keyword">int</span> <span class="keyword">const</span><span class="special">>::</span><span class="identifier">type</span></code> + </p> + </td> +<td> + <p> + <code class="computeroutput"><span class="keyword">int</span> <span class="keyword">const</span></code> + </p> + </td> +</tr> +</tbody> +</table></div> +</div> +<br class="table-break"> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="../reference.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="add_cv.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/reference/add_cv.html b/libs/type_traits/doc/html/boost_typetraits/reference/add_cv.html new file mode 100644 index 0000000000..17dca2916f --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/reference/add_cv.html @@ -0,0 +1,149 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>add_cv</title> +<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../reference.html" title="Alphabetical Reference"> +<link rel="prev" href="add_const.html" title="add_const"> +<link rel="next" href="add_lvalue_reference.html" title="add_lvalue_reference"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td> +<td align="center"><a href="../../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="add_const.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="add_lvalue_reference.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h3 class="title"> +<a name="boost_typetraits.reference.add_cv"></a><a class="link" href="add_cv.html" title="add_cv">add_cv</a> +</h3></div></div></div> +<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">add_cv</span> +<span class="special">{</span> + <span class="keyword">typedef</span> <em class="replaceable"><code>see-below</code></em> <span class="identifier">type</span><span class="special">;</span> +<span class="special">};</span> +</pre> +<p> + <span class="bold"><strong>type:</strong></span> The same type as <code class="computeroutput"><span class="identifier">T</span> + <span class="keyword">const</span> <span class="keyword">volatile</span></code> + for all <code class="computeroutput"><span class="identifier">T</span></code>. + </p> +<p> + <span class="bold"><strong>C++ Standard Reference:</strong></span> 3.9.3. + </p> +<p> + <span class="bold"><strong>Compiler Compatibility:</strong></span> If the compiler + does not support partial specialization of class-templates then this template + will compile, but the member <code class="computeroutput"><span class="identifier">type</span></code> + will always be the same as type <code class="computeroutput"><span class="identifier">T</span></code> + except where <a class="link" href="../category/transform.html#boost_typetraits.category.transform.broken_compiler_workarounds_">compiler + workarounds</a> have been applied. + </p> +<p> + <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"> <span class="preprocessor">#include</span> + <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">add_cv</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + </p> +<div class="table"> +<a name="boost_typetraits.reference.add_cv.examples"></a><p class="title"><b>Table 1.11. Examples</b></p> +<div class="table-contents"><table class="table" summary="Examples"> +<colgroup> +<col> +<col> +</colgroup> +<thead><tr> +<th> + <p> + Expression + </p> + </th> +<th> + <p> + Result Type + </p> + </th> +</tr></thead> +<tbody> +<tr> +<td> + <p> + <code class="computeroutput"><span class="identifier">add_cv</span><span class="special"><</span><span class="keyword">int</span><span class="special">>::</span><span class="identifier">type</span></code> + </p> + </td> +<td> + <p> + <code class="computeroutput"><span class="keyword">int</span> <span class="keyword">const</span> + <span class="keyword">volatile</span></code> + </p> + </td> +</tr> +<tr> +<td> + <p> + <code class="computeroutput"><span class="identifier">add_cv</span><span class="special"><</span><span class="keyword">int</span><span class="special">&>::</span><span class="identifier">type</span></code> + </p> + </td> +<td> + <p> + <code class="computeroutput"><span class="keyword">int</span><span class="special">&</span></code> + </p> + </td> +</tr> +<tr> +<td> + <p> + <code class="computeroutput"><span class="identifier">add_cv</span><span class="special"><</span><span class="keyword">int</span><span class="special">*>::</span><span class="identifier">type</span></code> + </p> + </td> +<td> + <p> + <code class="computeroutput"><span class="keyword">int</span><span class="special">*</span> + <span class="keyword">const</span> <span class="keyword">volatile</span></code> + </p> + </td> +</tr> +<tr> +<td> + <p> + <code class="computeroutput"><span class="identifier">add_cv</span><span class="special"><</span><span class="keyword">int</span> <span class="keyword">const</span><span class="special">>::</span><span class="identifier">type</span></code> + </p> + </td> +<td> + <p> + <code class="computeroutput"><span class="keyword">int</span> <span class="keyword">const</span> + <span class="keyword">volatile</span></code> + </p> + </td> +</tr> +</tbody> +</table></div> +</div> +<br class="table-break"> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="add_const.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="add_lvalue_reference.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/reference/add_lvalue_reference.html b/libs/type_traits/doc/html/boost_typetraits/reference/add_lvalue_reference.html new file mode 100644 index 0000000000..d70d608046 --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/reference/add_lvalue_reference.html @@ -0,0 +1,175 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>add_lvalue_reference</title> +<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../reference.html" title="Alphabetical Reference"> +<link rel="prev" href="add_cv.html" title="add_cv"> +<link rel="next" href="add_pointer.html" title="add_pointer"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td> +<td align="center"><a href="../../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="add_cv.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="add_pointer.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h3 class="title"> +<a name="boost_typetraits.reference.add_lvalue_reference"></a><a class="link" href="add_lvalue_reference.html" title="add_lvalue_reference">add_lvalue_reference</a> +</h3></div></div></div> +<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">add_lvalue_reference</span> +<span class="special">{</span> + <span class="keyword">typedef</span> <em class="replaceable"><code>see-below</code></em> <span class="identifier">type</span><span class="special">;</span> +<span class="special">};</span> +</pre> +<p> + <span class="bold"><strong>type:</strong></span> If <code class="computeroutput"><span class="identifier">T</span></code> + names an object or function type then the member typedef <code class="computeroutput"><span class="identifier">type</span></code> + shall name <code class="computeroutput"><span class="identifier">T</span><span class="special">&</span></code>; + otherwise, if <code class="computeroutput"><span class="identifier">T</span></code> names a type + <span class="emphasis"><em>rvalue reference to U</em></span> then the member typedef type shall + name <code class="computeroutput"><span class="identifier">U</span><span class="special">&</span></code>; + otherwise, type shall name <code class="computeroutput"><span class="identifier">T</span></code>. + </p> +<p> + <span class="bold"><strong>C++ Standard Reference:</strong></span> 20.7.6.2. + </p> +<p> + <span class="bold"><strong>Compiler Compatibility:</strong></span> If the compiler + does not support partial specialization of class-templates then this template + will compile, but the member <code class="computeroutput"><span class="identifier">type</span></code> + will always be the same as type <code class="computeroutput"><span class="identifier">T</span></code> + except where <a class="link" href="../category/transform.html#boost_typetraits.category.transform.broken_compiler_workarounds_">compiler + workarounds</a> have been applied. + </p> +<p> + <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"> <span class="preprocessor">#include</span> + <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">add_lvalue_reference</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + </p> +<div class="table"> +<a name="boost_typetraits.reference.add_lvalue_reference.examples"></a><p class="title"><b>Table 1.12. Examples</b></p> +<div class="table-contents"><table class="table" summary="Examples"> +<colgroup> +<col> +<col> +</colgroup> +<thead><tr> +<th> + <p> + Expression + </p> + </th> +<th> + <p> + Result Type + </p> + </th> +</tr></thead> +<tbody> +<tr> +<td> + <p> + <code class="computeroutput"><span class="identifier">add_lvalue_reference</span><span class="special"><</span><span class="keyword">int</span><span class="special">>::</span><span class="identifier">type</span></code> + </p> + </td> +<td> + <p> + <code class="computeroutput"><span class="keyword">int</span><span class="special">&</span></code> + </p> + </td> +</tr> +<tr> +<td> + <p> + <code class="computeroutput"><span class="identifier">add_lvalue_reference</span><span class="special"><</span><span class="keyword">int</span> + <span class="keyword">const</span><span class="special">&>::</span><span class="identifier">type</span></code> + </p> + </td> +<td> + <p> + <code class="computeroutput"><span class="keyword">int</span> <span class="keyword">const</span><span class="special">&</span></code> + </p> + </td> +</tr> +<tr> +<td> + <p> + <code class="computeroutput"><span class="identifier">add_lvalue_reference</span><span class="special"><</span><span class="keyword">int</span><span class="special">*>::</span><span class="identifier">type</span></code> + </p> + </td> +<td> + <p> + <code class="computeroutput"><span class="keyword">int</span><span class="special">*&</span></code> + </p> + </td> +</tr> +<tr> +<td> + <p> + <code class="computeroutput"><span class="identifier">add_lvalue_reference</span><span class="special"><</span><span class="keyword">int</span><span class="special">*&>::</span><span class="identifier">type</span></code> + </p> + </td> +<td> + <p> + <code class="computeroutput"><span class="keyword">int</span><span class="special">*&</span></code> + </p> + </td> +</tr> +<tr> +<td> + <p> + <code class="computeroutput"><span class="identifier">add_lvalue_reference</span><span class="special"><</span><span class="keyword">int</span><span class="special">&&>::</span><span class="identifier">type</span></code> + </p> + </td> +<td> + <p> + <code class="computeroutput"><span class="keyword">int</span><span class="special">&</span></code> + </p> + </td> +</tr> +<tr> +<td> + <p> + <code class="computeroutput"><span class="identifier">add_lvalue_reference</span><span class="special"><</span><span class="keyword">void</span><span class="special">>::</span><span class="identifier">type</span></code> + </p> + </td> +<td> + <p> + <code class="computeroutput"><span class="keyword">void</span></code> + </p> + </td> +</tr> +</tbody> +</table></div> +</div> +<br class="table-break"> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="add_cv.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="add_pointer.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/reference/add_pointer.html b/libs/type_traits/doc/html/boost_typetraits/reference/add_pointer.html new file mode 100644 index 0000000000..966beb3b3c --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/reference/add_pointer.html @@ -0,0 +1,148 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>add_pointer</title> +<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../reference.html" title="Alphabetical Reference"> +<link rel="prev" href="add_lvalue_reference.html" title="add_lvalue_reference"> +<link rel="next" href="add_reference.html" title="add_reference"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td> +<td align="center"><a href="../../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="add_lvalue_reference.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="add_reference.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h3 class="title"> +<a name="boost_typetraits.reference.add_pointer"></a><a class="link" href="add_pointer.html" title="add_pointer">add_pointer</a> +</h3></div></div></div> +<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">add_pointer</span> +<span class="special">{</span> + <span class="keyword">typedef</span> <em class="replaceable"><code>see-below</code></em> <span class="identifier">type</span><span class="special">;</span> +<span class="special">};</span> +</pre> +<p> + <span class="bold"><strong>type:</strong></span> The same type as <code class="computeroutput"><span class="identifier">remove_reference</span><span class="special"><</span><span class="identifier">T</span><span class="special">>::</span><span class="identifier">type</span><span class="special">*</span></code>. + </p> +<p> + The rationale for this template is that it produces the same type as <code class="computeroutput"><span class="identifier">TYPEOF</span><span class="special">(&</span><span class="identifier">t</span><span class="special">)</span></code>, where + <code class="computeroutput"><span class="identifier">t</span></code> is an object of type <code class="computeroutput"><span class="identifier">T</span></code>. + </p> +<p> + <span class="bold"><strong>C++ Standard Reference:</strong></span> 8.3.1. + </p> +<p> + <span class="bold"><strong>Compiler Compatibility:</strong></span> If the compiler + does not support partial specialization of class-templates then this template + will compile, but the member <code class="computeroutput"><span class="identifier">type</span></code> + will always be the same as type <code class="computeroutput"><span class="identifier">T</span></code> + except where <a class="link" href="../category/transform.html#boost_typetraits.category.transform.broken_compiler_workarounds_">compiler + workarounds</a> have been applied. + </p> +<p> + <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"> <span class="preprocessor">#include</span> + <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">add_pointer</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + </p> +<div class="table"> +<a name="boost_typetraits.reference.add_pointer.examples"></a><p class="title"><b>Table 1.13. Examples</b></p> +<div class="table-contents"><table class="table" summary="Examples"> +<colgroup> +<col> +<col> +</colgroup> +<thead><tr> +<th> + <p> + Expression + </p> + </th> +<th> + <p> + Result Type + </p> + </th> +</tr></thead> +<tbody> +<tr> +<td> + <p> + <code class="computeroutput"><span class="identifier">add_pointer</span><span class="special"><</span><span class="keyword">int</span><span class="special">>::</span><span class="identifier">type</span></code> + </p> + </td> +<td> + <p> + <code class="computeroutput"><span class="keyword">int</span><span class="special">*</span></code> + </p> + </td> +</tr> +<tr> +<td> + <p> + <code class="computeroutput"><span class="identifier">add_pointer</span><span class="special"><</span><span class="keyword">int</span> <span class="keyword">const</span><span class="special">&>::</span><span class="identifier">type</span></code> + </p> + </td> +<td> + <p> + <code class="computeroutput"><span class="keyword">int</span> <span class="keyword">const</span><span class="special">*</span></code> + </p> + </td> +</tr> +<tr> +<td> + <p> + <code class="computeroutput"><span class="identifier">add_pointer</span><span class="special"><</span><span class="keyword">int</span><span class="special">*>::</span><span class="identifier">type</span></code> + </p> + </td> +<td> + <p> + <code class="computeroutput"><span class="keyword">int</span><span class="special">**</span></code> + </p> + </td> +</tr> +<tr> +<td> + <p> + <code class="computeroutput"><span class="identifier">add_pointer</span><span class="special"><</span><span class="keyword">int</span><span class="special">*&>::</span><span class="identifier">type</span></code> + </p> + </td> +<td> + <p> + <code class="computeroutput"><span class="keyword">int</span><span class="special">**</span></code> + </p> + </td> +</tr> +</tbody> +</table></div> +</div> +<br class="table-break"> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="add_lvalue_reference.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="add_reference.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/reference/add_reference.html b/libs/type_traits/doc/html/boost_typetraits/reference/add_reference.html new file mode 100644 index 0000000000..d48b4cf3d1 --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/reference/add_reference.html @@ -0,0 +1,157 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>add_reference</title> +<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../reference.html" title="Alphabetical Reference"> +<link rel="prev" href="add_pointer.html" title="add_pointer"> +<link rel="next" href="add_rvalue_reference.html" title="add_rvalue_reference"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td> +<td align="center"><a href="../../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="add_pointer.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="add_rvalue_reference.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h3 class="title"> +<a name="boost_typetraits.reference.add_reference"></a><a class="link" href="add_reference.html" title="add_reference">add_reference</a> +</h3></div></div></div> +<div class="note"><table border="0" summary="Note"> +<tr> +<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../../doc/src/images/note.png"></td> +<th align="left">Note</th> +</tr> +<tr><td align="left" valign="top"><p> + This trait has been made obsolete by <a class="link" href="add_lvalue_reference.html" title="add_lvalue_reference">add_lvalue_reference</a> + and <a class="link" href="add_rvalue_reference.html" title="add_rvalue_reference">add_rvalue_reference</a>, + and new code should use these new traits rather than <a class="link" href="is_reference.html" title="is_reference">is_reference</a> + which is retained for backwards compatibility only. + </p></td></tr> +</table></div> +<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">add_reference</span> +<span class="special">{</span> + <span class="keyword">typedef</span> <em class="replaceable"><code>see-below</code></em> <span class="identifier">type</span><span class="special">;</span> +<span class="special">};</span> +</pre> +<p> + <span class="bold"><strong>type:</strong></span> If <code class="computeroutput"><span class="identifier">T</span></code> + is not a reference type then <code class="computeroutput"><span class="identifier">T</span><span class="special">&</span></code>, otherwise <code class="computeroutput"><span class="identifier">T</span></code>. + </p> +<p> + <span class="bold"><strong>C++ Standard Reference:</strong></span> 8.3.2. + </p> +<p> + <span class="bold"><strong>Compiler Compatibility:</strong></span> If the compiler + does not support partial specialization of class-templates then this template + will compile, but the member <code class="computeroutput"><span class="identifier">type</span></code> + will always be the same as type <code class="computeroutput"><span class="identifier">T</span></code> + except where <a class="link" href="../category/transform.html#boost_typetraits.category.transform.broken_compiler_workarounds_">compiler + workarounds</a> have been applied. + </p> +<p> + <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"> <span class="preprocessor">#include</span> + <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">add_reference</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + </p> +<div class="table"> +<a name="boost_typetraits.reference.add_reference.examples"></a><p class="title"><b>Table 1.14. Examples</b></p> +<div class="table-contents"><table class="table" summary="Examples"> +<colgroup> +<col> +<col> +</colgroup> +<thead><tr> +<th> + <p> + Expression + </p> + </th> +<th> + <p> + Result Type + </p> + </th> +</tr></thead> +<tbody> +<tr> +<td> + <p> + <code class="computeroutput"><span class="identifier">add_reference</span><span class="special"><</span><span class="keyword">int</span><span class="special">>::</span><span class="identifier">type</span></code> + </p> + </td> +<td> + <p> + <code class="computeroutput"><span class="keyword">int</span><span class="special">&</span></code> + </p> + </td> +</tr> +<tr> +<td> + <p> + <code class="computeroutput"><span class="identifier">add_reference</span><span class="special"><</span><span class="keyword">int</span> <span class="keyword">const</span><span class="special">&>::</span><span class="identifier">type</span></code> + </p> + </td> +<td> + <p> + <code class="computeroutput"><span class="keyword">int</span> <span class="keyword">const</span><span class="special">&</span></code> + </p> + </td> +</tr> +<tr> +<td> + <p> + <code class="computeroutput"><span class="identifier">add_reference</span><span class="special"><</span><span class="keyword">int</span><span class="special">*>::</span><span class="identifier">type</span></code> + </p> + </td> +<td> + <p> + <code class="computeroutput"><span class="keyword">int</span><span class="special">*&</span></code> + </p> + </td> +</tr> +<tr> +<td> + <p> + <code class="computeroutput"><span class="identifier">add_reference</span><span class="special"><</span><span class="keyword">int</span><span class="special">*&>::</span><span class="identifier">type</span></code> + </p> + </td> +<td> + <p> + <code class="computeroutput"><span class="keyword">int</span><span class="special">*&</span></code> + </p> + </td> +</tr> +</tbody> +</table></div> +</div> +<br class="table-break"> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="add_pointer.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="add_rvalue_reference.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/reference/add_rvalue_reference.html b/libs/type_traits/doc/html/boost_typetraits/reference/add_rvalue_reference.html new file mode 100644 index 0000000000..da4e66f506 --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/reference/add_rvalue_reference.html @@ -0,0 +1,173 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>add_rvalue_reference</title> +<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../reference.html" title="Alphabetical Reference"> +<link rel="prev" href="add_reference.html" title="add_reference"> +<link rel="next" href="add_volatile.html" title="add_volatile"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td> +<td align="center"><a href="../../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="add_reference.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="add_volatile.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h3 class="title"> +<a name="boost_typetraits.reference.add_rvalue_reference"></a><a class="link" href="add_rvalue_reference.html" title="add_rvalue_reference">add_rvalue_reference</a> +</h3></div></div></div> +<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">add_rvalue_reference</span> +<span class="special">{</span> + <span class="keyword">typedef</span> <em class="replaceable"><code>see-below</code></em> <span class="identifier">type</span><span class="special">;</span> +<span class="special">};</span> +</pre> +<p> + <span class="bold"><strong>type:</strong></span> If <code class="computeroutput"><span class="identifier">T</span></code> + names an object or function type then the member typedef type shall name + <code class="computeroutput"><span class="identifier">T</span><span class="special">&&</span></code>; + otherwise, type shall name <code class="computeroutput"><span class="identifier">T</span></code>. + <span class="emphasis"><em>[Note: This rule reflects the semantics of reference collapsing. + For example, when a type <code class="computeroutput"><span class="identifier">T</span></code> + names a type U&, the type <code class="computeroutput"><span class="identifier">add_rvalue_reference</span><span class="special"><</span><span class="identifier">T</span><span class="special">>::</span><span class="identifier">type</span></code> is not an rvalue reference. -end note]</em></span>. + </p> +<p> + <span class="bold"><strong>C++ Standard Reference:</strong></span> 20.7.6.2. + </p> +<p> + <span class="bold"><strong>Compiler Compatibility:</strong></span> If the compiler + does not support partial specialization of class-templates and rvalue references + then this template will compile, but the member <code class="computeroutput"><span class="identifier">type</span></code> + will always be the same as type <code class="computeroutput"><span class="identifier">T</span></code>. + </p> +<p> + <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"> <span class="preprocessor">#include</span> + <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">add_rvalue_reference</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + </p> +<div class="table"> +<a name="boost_typetraits.reference.add_rvalue_reference.examples"></a><p class="title"><b>Table 1.15. Examples</b></p> +<div class="table-contents"><table class="table" summary="Examples"> +<colgroup> +<col> +<col> +</colgroup> +<thead><tr> +<th> + <p> + Expression + </p> + </th> +<th> + <p> + Result Type + </p> + </th> +</tr></thead> +<tbody> +<tr> +<td> + <p> + <code class="computeroutput"><span class="identifier">add_rvalue_reference</span><span class="special"><</span><span class="keyword">int</span><span class="special">>::</span><span class="identifier">type</span></code> + </p> + </td> +<td> + <p> + <code class="computeroutput"><span class="keyword">int</span><span class="special">&&</span></code> + </p> + </td> +</tr> +<tr> +<td> + <p> + <code class="computeroutput"><span class="identifier">add_rvalue_reference</span><span class="special"><</span><span class="keyword">int</span> + <span class="keyword">const</span><span class="special">&>::</span><span class="identifier">type</span></code> + </p> + </td> +<td> + <p> + <code class="computeroutput"><span class="keyword">int</span> <span class="keyword">const</span><span class="special">&</span></code> + </p> + </td> +</tr> +<tr> +<td> + <p> + <code class="computeroutput"><span class="identifier">add_rvalue_reference</span><span class="special"><</span><span class="keyword">int</span><span class="special">*>::</span><span class="identifier">type</span></code> + </p> + </td> +<td> + <p> + <code class="computeroutput"><span class="keyword">int</span><span class="special">*&&</span></code> + </p> + </td> +</tr> +<tr> +<td> + <p> + <code class="computeroutput"><span class="identifier">add_rvalue_reference</span><span class="special"><</span><span class="keyword">int</span><span class="special">*&>::</span><span class="identifier">type</span></code> + </p> + </td> +<td> + <p> + <code class="computeroutput"><span class="keyword">int</span><span class="special">*&</span></code> + </p> + </td> +</tr> +<tr> +<td> + <p> + <code class="computeroutput"><span class="identifier">add_rvalue_reference</span><span class="special"><</span><span class="keyword">int</span><span class="special">&&>::</span><span class="identifier">type</span></code> + </p> + </td> +<td> + <p> + <code class="computeroutput"><span class="keyword">int</span><span class="special">&&</span></code> + </p> + </td> +</tr> +<tr> +<td> + <p> + <code class="computeroutput"><span class="identifier">add_rvalue_reference</span><span class="special"><</span><span class="keyword">void</span><span class="special">>::</span><span class="identifier">type</span></code> + </p> + </td> +<td> + <p> + <code class="computeroutput"><span class="keyword">void</span></code> + </p> + </td> +</tr> +</tbody> +</table></div> +</div> +<br class="table-break"> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="add_reference.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="add_volatile.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/reference/add_volatile.html b/libs/type_traits/doc/html/boost_typetraits/reference/add_volatile.html new file mode 100644 index 0000000000..e55fa0005e --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/reference/add_volatile.html @@ -0,0 +1,147 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>add_volatile</title> +<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../reference.html" title="Alphabetical Reference"> +<link rel="prev" href="add_rvalue_reference.html" title="add_rvalue_reference"> +<link rel="next" href="aligned_storage.html" title="aligned_storage"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td> +<td align="center"><a href="../../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="add_rvalue_reference.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="aligned_storage.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h3 class="title"> +<a name="boost_typetraits.reference.add_volatile"></a><a class="link" href="add_volatile.html" title="add_volatile">add_volatile</a> +</h3></div></div></div> +<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">add_volatile</span> +<span class="special">{</span> + <span class="keyword">typedef</span> <em class="replaceable"><code>see-below</code></em> <span class="identifier">type</span><span class="special">;</span> +<span class="special">};</span> +</pre> +<p> + <span class="bold"><strong>type:</strong></span> The same type as <code class="computeroutput"><span class="identifier">T</span> + <span class="keyword">volatile</span></code> for all <code class="computeroutput"><span class="identifier">T</span></code>. + </p> +<p> + <span class="bold"><strong>C++ Standard Reference:</strong></span> 3.9.3. + </p> +<p> + <span class="bold"><strong>Compiler Compatibility:</strong></span> If the compiler + does not support partial specialization of class-templates then this template + will compile, but the member <code class="computeroutput"><span class="identifier">type</span></code> + will always be the same as type <code class="computeroutput"><span class="identifier">T</span></code> + except where <a class="link" href="../category/transform.html#boost_typetraits.category.transform.broken_compiler_workarounds_">compiler + workarounds</a> have been applied. + </p> +<p> + <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"> <span class="preprocessor">#include</span> + <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">add_volatile</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + </p> +<div class="table"> +<a name="boost_typetraits.reference.add_volatile.examples"></a><p class="title"><b>Table 1.16. Examples</b></p> +<div class="table-contents"><table class="table" summary="Examples"> +<colgroup> +<col> +<col> +</colgroup> +<thead><tr> +<th> + <p> + Expression + </p> + </th> +<th> + <p> + Result Type + </p> + </th> +</tr></thead> +<tbody> +<tr> +<td> + <p> + <code class="computeroutput"><span class="identifier">add_volatile</span><span class="special"><</span><span class="keyword">int</span><span class="special">>::</span><span class="identifier">type</span></code> + </p> + </td> +<td> + <p> + <code class="computeroutput"><span class="keyword">int</span> <span class="keyword">volatile</span></code> + </p> + </td> +</tr> +<tr> +<td> + <p> + <code class="computeroutput"><span class="identifier">add_volatile</span><span class="special"><</span><span class="keyword">int</span><span class="special">&>::</span><span class="identifier">type</span></code> + </p> + </td> +<td> + <p> + <code class="computeroutput"><span class="keyword">int</span><span class="special">&</span></code> + </p> + </td> +</tr> +<tr> +<td> + <p> + <code class="computeroutput"><span class="identifier">add_volatile</span><span class="special"><</span><span class="keyword">int</span><span class="special">*>::</span><span class="identifier">type</span></code> + </p> + </td> +<td> + <p> + <code class="computeroutput"><span class="keyword">int</span><span class="special">*</span> + <span class="keyword">volatile</span></code> + </p> + </td> +</tr> +<tr> +<td> + <p> + <code class="computeroutput"><span class="identifier">add_volatile</span><span class="special"><</span><span class="keyword">int</span> <span class="keyword">const</span><span class="special">>::</span><span class="identifier">type</span></code> + </p> + </td> +<td> + <p> + <code class="computeroutput"><span class="keyword">int</span> <span class="keyword">const</span> + <span class="keyword">volatile</span></code> + </p> + </td> +</tr> +</tbody> +</table></div> +</div> +<br class="table-break"> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="add_rvalue_reference.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="aligned_storage.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/reference/aligned_storage.html b/libs/type_traits/doc/html/boost_typetraits/reference/aligned_storage.html new file mode 100644 index 0000000000..94afbeec04 --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/reference/aligned_storage.html @@ -0,0 +1,63 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>aligned_storage</title> +<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../reference.html" title="Alphabetical Reference"> +<link rel="prev" href="add_volatile.html" title="add_volatile"> +<link rel="next" href="alignment_of.html" title="alignment_of"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td> +<td align="center"><a href="../../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="add_volatile.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="alignment_of.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h3 class="title"> +<a name="boost_typetraits.reference.aligned_storage"></a><a class="link" href="aligned_storage.html" title="aligned_storage">aligned_storage</a> +</h3></div></div></div> +<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">Size</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">Align</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">aligned_storage</span> +<span class="special">{</span> + <span class="keyword">typedef</span> <em class="replaceable"><code>see-below</code></em> <span class="identifier">type</span><span class="special">;</span> +<span class="special">};</span> +</pre> +<p> + <span class="bold"><strong>type:</strong></span> a built-in or POD type with size + <code class="computeroutput"><span class="identifier">Size</span></code> and an alignment that + is a multiple of <code class="computeroutput"><span class="identifier">Align</span></code>. + </p> +<p> + <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"> <span class="preprocessor">#include</span> + <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">aligned_storage</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + </p> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="add_volatile.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="alignment_of.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/reference/alignment_of.html b/libs/type_traits/doc/html/boost_typetraits/reference/alignment_of.html new file mode 100644 index 0000000000..d2f4f0e74c --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/reference/alignment_of.html @@ -0,0 +1,83 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>alignment_of</title> +<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../reference.html" title="Alphabetical Reference"> +<link rel="prev" href="aligned_storage.html" title="aligned_storage"> +<link rel="next" href="conditional.html" title="conditional"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td> +<td align="center"><a href="../../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="aligned_storage.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="conditional.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h3 class="title"> +<a name="boost_typetraits.reference.alignment_of"></a><a class="link" href="alignment_of.html" title="alignment_of">alignment_of</a> +</h3></div></div></div> +<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">alignment_of</span> <span class="special">:</span> <span class="keyword">public</span> <a class="link" href="integral_constant.html" title="integral_constant">integral_constant</a><span class="special"><</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span><span class="special">,</span> <span class="identifier">ALIGNOF</span><span class="special">(</span><span class="identifier">T</span><span class="special">)></span> <span class="special">{};</span> +</pre> +<p> + <span class="bold"><strong>Inherits:</strong></span> Class template <code class="computeroutput"><span class="identifier">alignment_of</span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">integral_constant</a><span class="special"><</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span><span class="special">,</span> <span class="identifier">ALIGNOF</span><span class="special">(</span><span class="identifier">T</span><span class="special">)></span></code>, + where <code class="computeroutput"><span class="identifier">ALIGNOF</span><span class="special">(</span><span class="identifier">T</span><span class="special">)</span></code> is the + alignment of type T. + </p> +<p> + <span class="emphasis"><em>Note: strictly speaking you should only rely on the value of <code class="computeroutput"><span class="identifier">ALIGNOF</span><span class="special">(</span><span class="identifier">T</span><span class="special">)</span></code> 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.</em></span> + </p> +<p> + <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"> <span class="preprocessor">#include</span> + <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">alignment_of</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + </p> +<p> + <span class="bold"><strong>Examples:</strong></span> + </p> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">alignment_of</span><span class="special"><</span><span class="keyword">int</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">integral_constant</a><span class="special"><</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span><span class="special">,</span> <span class="identifier">ALIGNOF</span><span class="special">(</span><span class="keyword">int</span><span class="special">)></span></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">alignment_of</span><span class="special"><</span><span class="keyword">char</span><span class="special">>::</span><span class="identifier">type</span></code> is the type <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">integral_constant</a><span class="special"><</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span><span class="special">,</span> <span class="identifier">ALIGNOF</span><span class="special">(</span><span class="keyword">char</span><span class="special">)></span></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">alignment_of</span><span class="special"><</span><span class="keyword">double</span><span class="special">>::</span><span class="identifier">value</span></code> is an integral constant expression + with value <code class="computeroutput"><span class="identifier">ALIGNOF</span><span class="special">(</span><span class="keyword">double</span><span class="special">)</span></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">alignment_of</span><span class="special"><</span><span class="identifier">T</span><span class="special">>::</span><span class="identifier">value_type</span></code> is the type <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span></code>. + </p></blockquote></div> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="aligned_storage.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="conditional.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/reference/common_type.html b/libs/type_traits/doc/html/boost_typetraits/reference/common_type.html new file mode 100644 index 0000000000..16190ce3df --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/reference/common_type.html @@ -0,0 +1,353 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>common_type</title> +<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../reference.html" title="Alphabetical Reference"> +<link rel="prev" href="conditional.html" title="conditional"> +<link rel="next" href="decay.html" title="decay"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td> +<td align="center"><a href="../../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="conditional.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="decay.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h3 class="title"> +<a name="boost_typetraits.reference.common_type"></a><a class="link" href="common_type.html" title="common_type">common_type</a> +</h3></div></div></div> +<p> + <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"> <span class="preprocessor">#include</span> + <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">common_type</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + </p> +<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span> + <span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="special">...</span><span class="identifier">T</span><span class="special">></span> <span class="keyword">struct</span> <a class="link" href="common_type.html" title="common_type">common_type</a><span class="special">;</span> +<span class="special">}</span> +</pre> +<p> + <a class="link" href="common_type.html" title="common_type">common_type</a> + is a traits class used to deduce a type common to a several types, useful + as the return type of functions operating on multiple input types such as + in mixed-mode arithmetic.. + </p> +<p> + The nested typedef <code class="computeroutput"><span class="special">::</span><span class="identifier">type</span></code> + could be defined as follows: + </p> +<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="special">...</span><span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">common_type</span><span class="special">;</span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">U</span><span class="special">,</span> <span class="keyword">class</span> <span class="special">...</span><span class="identifier">V</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">common_type</span><span class="special"><</span><span class="identifier">T</span><span class="special">,</span><span class="identifier">U</span><span class="special">,...</span><span class="identifier">V</span><span class="special">></span> <span class="special">{</span> + <span class="keyword">typedef</span> <span class="keyword">typename</span> <a class="link" href="common_type.html" title="common_type">common_type</a><span class="special"><</span><span class="keyword">typename</span> <a class="link" href="common_type.html" title="common_type">common_type</a><span class="special"><</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">U</span><span class="special">>::</span><span class="identifier">type</span><span class="special">,</span> <span class="identifier">V</span><span class="special">...>::</span><span class="identifier">type</span> <span class="identifier">type</span><span class="special">;</span> +<span class="special">};</span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">common_type</span><span class="special"><</span><span class="identifier">T</span><span class="special">></span> <span class="special">{</span> + <span class="keyword">typedef</span> <span class="identifier">T</span> <span class="identifier">type</span><span class="special">;</span> +<span class="special">};</span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">U</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">common_type</span><span class="special"><</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">U</span><span class="special">></span> <span class="special">{</span> + <span class="keyword">typedef</span> <span class="identifier">decltype</span><span class="special">(</span><a href="../../../../../utility/doc/html/declval.html" target="_top">declval</a><span class="special"><</span><span class="keyword">bool</span><span class="special">>()</span> <span class="special">?</span> <a href="../../../../../utility/doc/html/declval.html" target="_top">declval</a><span class="special"><</span><span class="identifier">T</span><span class="special">>()</span> <span class="special">:</span> <a href="../../../../../utility/doc/html/declval.html" target="_top">declval</a><span class="special"><</span><span class="identifier">U</span><span class="special">>())</span> <span class="identifier">type</span><span class="special">;</span> +<span class="special">};</span> +</pre> +<p> + All parameter types must be complete. This trait is permitted to be specialized + by a user if at least one template parameter is a user-defined type. <span class="bold"><strong>Note:</strong></span> Such specializations are required when only + explicit conversions are desired among the <a class="link" href="common_type.html" title="common_type">common_type</a> + arguments. + </p> +<p> + Note that when the compiler does not support variadic templates (and the + macro BOOST_NO_VARIADIC_TEMPLATES is defined) then the maximum number of + template arguments is 3. + </p> +<a name="boost_typetraits.reference.common_type.configuration_macros"></a><h5> +<a name="boost_typetraits.reference.common_type.configuration_macros-heading"></a> + <a class="link" href="common_type.html#boost_typetraits.reference.common_type.configuration_macros">Configuration + macros</a> + </h5> +<p> + When the compiler does not support static assertions then the user can select + the way static assertions are reported. Define + </p> +<div class="itemizedlist"><ul class="itemizedlist" type="disc"> +<li class="listitem"> + BOOST_COMMON_TYPE_USES_STATIC_ASSERT: define it if you want to use Boost.StaticAssert + </li> +<li class="listitem"> + BOOST_COMMON_TYPE_USES_MPL_ASSERT: define it if you want to use Boost.MPL + static asertions + </li> +</ul></div> +<p> + The default behavior is to use mpl assertions in this case, but setting BOOST_COMMON_TYPE_USES_STATIC_ASSERT + may reduce compile times and header dependencies somewhat. + </p> +<p> + Depending on the static assertion used you will have an hint of the failing + assertion either through the symbol or through the text. + </p> +<p> + When possible common_type is implemented using <code class="computeroutput"><span class="identifier">decltype</span></code>. + Otherwise when BOOST_COMMON_TYPE_DONT_USE_TYPEOF is not defined it uses Boost.TypeOf. + </p> +<a name="boost_typetraits.reference.common_type.tutorial"></a><h5> +<a name="boost_typetraits.reference.common_type.tutorial-heading"></a> + <a class="link" href="common_type.html#boost_typetraits.reference.common_type.tutorial">Tutorial</a> + </h5> +<p> + In a nutshell, <a class="link" href="common_type.html" title="common_type">common_type</a> + is a trait that takes 1 or more types, and returns a type which all of the + types will convert to. The default definition demands this conversion be + implicit. However the trait can be specialized for user-defined types which + want to limit their inter-type conversions to explicit, and yet still want + to interoperate with the <a class="link" href="common_type.html" title="common_type">common_type</a> + facility. + </p> +<p> + <span class="bold"><strong>Example:</strong></span> + </p> +<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">U</span><span class="special">></span> +<span class="identifier">complex</span><span class="special"><</span><span class="keyword">typename</span> <a class="link" href="common_type.html" title="common_type">common_type</a><span class="special"><</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">U</span><span class="special">>::</span><span class="identifier">type</span><span class="special">></span> +<span class="keyword">operator</span><span class="special">+(</span><span class="identifier">complex</span><span class="special"><</span><span class="identifier">T</span><span class="special">>,</span> <span class="identifier">complex</span><span class="special"><</span><span class="identifier">U</span><span class="special">>);</span> +</pre> +<p> + In the above example, "mixed-mode" complex arithmetic is allowed. + The return type is described by <a class="link" href="common_type.html" title="common_type">common_type</a>. + For example the resulting type of adding a <code class="computeroutput"><span class="identifier">complex</span><span class="special"><</span><span class="keyword">float</span><span class="special">></span></code> and <code class="computeroutput"><span class="identifier">complex</span><span class="special"><</span><span class="keyword">double</span><span class="special">></span></code> might be a <code class="computeroutput"><span class="identifier">complex</span><span class="special"><</span><span class="keyword">double</span><span class="special">></span></code>. + </p> +<p> + Here is how someone might produce a variadic comparison function: + </p> +<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="special">...</span><span class="identifier">T</span><span class="special">></span> +<span class="keyword">typename</span> <a class="link" href="common_type.html" title="common_type">common_type</a><span class="special"><</span><span class="identifier">T</span><span class="special">...>::</span><span class="identifier">type</span> +<span class="identifier">min</span><span class="special">(</span><span class="identifier">T</span><span class="special">...</span> <span class="identifier">t</span><span class="special">);</span> +</pre> +<p> + This is a very useful and broadly applicable utility. + </p> +<a name="boost_typetraits.reference.common_type.how_to_get_the_common_type_of_types_with_explicit_conversions_"></a><h5> +<a name="boost_typetraits.reference.common_type.how_to_get_the_common_type_of_types_with_explicit_conversions_-heading"></a> + <a class="link" href="common_type.html#boost_typetraits.reference.common_type.how_to_get_the_common_type_of_types_with_explicit_conversions_">How + to get the common type of types with explicit conversions?</a> + </h5> +<p> + Another choice for the author of the preceding operator could be + </p> +<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">U</span><span class="special">></span> +<span class="keyword">typename</span> <a class="link" href="common_type.html" title="common_type">common_type</a><span class="special"><</span><span class="identifier">complex</span><span class="special"><</span><span class="identifier">T</span><span class="special">>,</span> <span class="identifier">complex</span><span class="special"><</span><span class="identifier">U</span><span class="special">></span> <span class="special">>::</span><span class="identifier">type</span> +<span class="keyword">operator</span><span class="special">+(</span><span class="identifier">complex</span><span class="special"><</span><span class="identifier">T</span><span class="special">>,</span> <span class="identifier">complex</span><span class="special"><</span><span class="identifier">U</span><span class="special">>);</span> +</pre> +<p> + As the default definition of <a class="link" href="common_type.html" title="common_type">common_type</a> + demands the conversion be implicit, we need to specialize the trait for complex + types as follows. + </p> +<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">U</span><span class="special">></span> +<span class="keyword">struct</span> <a class="link" href="common_type.html" title="common_type">common_type</a><span class="special"><</span><span class="identifier">complex</span><span class="special"><</span><span class="identifier">T</span><span class="special">>,</span> <span class="identifier">complex</span><span class="special"><</span><span class="identifier">U</span><span class="special">></span> <span class="special">></span> <span class="special">{</span> + <span class="keyword">typedef</span> <span class="identifier">complex</span><span class="special"><</span> <a class="link" href="common_type.html" title="common_type">common_type</a><span class="special"><</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">U</span><span class="special">></span> <span class="special">></span> <span class="identifier">type</span><span class="special">;</span> +<span class="special">};</span> +</pre> +<a name="boost_typetraits.reference.common_type.how_important_is_the_order_of_the_common_type_lt__gt__template_arguments_"></a><h5> +<a name="boost_typetraits.reference.common_type.how_important_is_the_order_of_the_common_type_lt__gt__template_arguments_-heading"></a> + <a class="link" href="common_type.html#boost_typetraits.reference.common_type.how_important_is_the_order_of_the_common_type_lt__gt__template_arguments_">How + important is the order of the common_type<> template arguments?</a> + </h5> +<p> + The order of the template parameters is important. + </p> +<p> + <code class="computeroutput"><span class="identifier">common_type</span><span class="special"><</span><span class="identifier">A</span><span class="special">,</span><span class="identifier">B</span><span class="special">,</span><span class="identifier">C</span><span class="special">>::</span><span class="identifier">type</span></code> is not equivalent to <code class="computeroutput"><span class="identifier">common_type</span><span class="special"><</span><span class="identifier">C</span><span class="special">,</span><span class="identifier">A</span><span class="special">,</span><span class="identifier">B</span><span class="special">>::</span><span class="identifier">type</span></code>, but to <code class="computeroutput"><span class="identifier">common_type</span><span class="special"><</span><span class="identifier">common_type</span><span class="special"><</span><span class="identifier">A</span><span class="special">,</span><span class="identifier">B</span><span class="special">>::</span><span class="identifier">type</span><span class="special">,</span> <span class="identifier">C</span><span class="special">>::</span><span class="identifier">type</span></code>. + </p> +<p> + Consider + </p> +<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{};</span> +<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{};</span> +<span class="keyword">struct</span> <span class="identifier">C</span> <span class="special">{</span> + <span class="identifier">C</span><span class="special">()</span> <span class="special">{}</span> + <span class="identifier">C</span><span class="special">(</span><span class="identifier">A</span> <span class="keyword">const</span><span class="special">&)</span> <span class="special">{}</span> + <span class="identifier">C</span><span class="special">(</span><span class="identifier">B</span> <span class="keyword">const</span><span class="special">&)</span> <span class="special">{}</span> + <span class="identifier">C</span><span class="special">&</span> <span class="keyword">operator</span><span class="special">=(</span><span class="identifier">C</span> <span class="keyword">const</span><span class="special">&)</span> <span class="special">{</span> + <span class="keyword">return</span> <span class="special">*</span><span class="keyword">this</span><span class="special">;</span> + <span class="special">}</span> +<span class="special">};</span> +</pre> +<p> + The following doesn't compile + </p> +<pre class="programlisting"><span class="keyword">typedef</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">common_type</span><span class="special"><</span><span class="identifier">A</span><span class="special">,</span> <span class="identifier">B</span><span class="special">,</span> <span class="identifier">C</span><span class="special">>::</span><span class="identifier">type</span> <span class="identifier">ABC</span><span class="special">;</span> <span class="comment">// Does not compile</span> +</pre> +<p> + while + </p> +<pre class="programlisting"><span class="keyword">typedef</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">common_type</span><span class="special"><</span><span class="identifier">C</span><span class="special">,</span> <span class="identifier">A</span><span class="special">,</span> <span class="identifier">B</span><span class="special">>::</span><span class="identifier">type</span> <span class="identifier">ABC</span><span class="special">;</span> +</pre> +<p> + compiles. + </p> +<p> + Thus, as <code class="computeroutput"><span class="identifier">common_type</span><span class="special"><</span><span class="identifier">A</span><span class="special">,</span><span class="identifier">B</span><span class="special">>::</span><span class="identifier">type</span></code> + is undefined, <code class="computeroutput"><span class="identifier">common_type</span><span class="special"><</span><span class="identifier">A</span><span class="special">,</span><span class="identifier">B</span><span class="special">,</span><span class="identifier">C</span><span class="special">>::</span><span class="identifier">type</span></code> + is also undefined. + </p> +<p> + It is intended that clients who wish for <code class="computeroutput"><span class="identifier">common_type</span><span class="special"><</span><span class="identifier">A</span><span class="special">,</span> + <span class="identifier">B</span><span class="special">></span></code> + to be well defined to define it themselves: + </p> +<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span> +<span class="special">{</span> + +<span class="keyword">template</span> <span class="special"><></span> +<span class="keyword">struct</span> <span class="identifier">common_type</span><span class="special"><</span><span class="identifier">A</span><span class="special">,</span> <span class="identifier">B</span><span class="special">></span> <span class="special">{</span><span class="keyword">typedef</span> <span class="identifier">C</span> <span class="identifier">type</span><span class="special">;};</span> + +<span class="special">}</span> +</pre> +<p> + Now this client can ask for <code class="computeroutput"><span class="identifier">common_type</span><span class="special"><</span><span class="identifier">A</span><span class="special">,</span> + <span class="identifier">B</span><span class="special">,</span> <span class="identifier">C</span><span class="special">></span></code> (and + get the same answer). + </p> +<p> + Clients wanting to ask <code class="computeroutput"><span class="identifier">common_type</span><span class="special"><</span><span class="identifier">A</span><span class="special">,</span> + <span class="identifier">B</span><span class="special">,</span> <span class="identifier">C</span><span class="special">></span></code> in + any order and get the same result need to add in addition: + </p> +<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span> +<span class="special">{</span> + +<span class="keyword">template</span> <span class="special"><></span> <span class="keyword">struct</span> <span class="identifier">common_type</span><span class="special"><</span><span class="identifier">B</span><span class="special">,</span> <span class="identifier">A</span><span class="special">></span> +<span class="special">:</span> <span class="keyword">public</span> <span class="identifier">common_type</span><span class="special"><</span><span class="identifier">A</span><span class="special">,</span> <span class="identifier">B</span><span class="special">></span> <span class="special">{};</span> + +<span class="special">}</span> +</pre> +<p> + This is needed as the specialization of <code class="computeroutput"><span class="identifier">common_type</span><span class="special"><</span><span class="identifier">A</span><span class="special">,</span> + <span class="identifier">B</span><span class="special">></span></code> + is not be used implicitly for <code class="computeroutput"><span class="identifier">common_type</span><span class="special"><</span><span class="identifier">B</span><span class="special">,</span> + <span class="identifier">A</span><span class="special">></span></code>. + </p> +<a name="boost_typetraits.reference.common_type.can_the_common_type_of_two_types_be_a_third_type_"></a><h5> +<a name="boost_typetraits.reference.common_type.can_the_common_type_of_two_types_be_a_third_type_-heading"></a> + <a class="link" href="common_type.html#boost_typetraits.reference.common_type.can_the_common_type_of_two_types_be_a_third_type_">Can + the common_type of two types be a third type?</a> + </h5> +<p> + Given the preceding example, one might expect <code class="computeroutput"><span class="identifier">common_type</span><span class="special"><</span><span class="identifier">A</span><span class="special">,</span><span class="identifier">B</span><span class="special">>::</span><span class="identifier">type</span></code> to be <code class="computeroutput"><span class="identifier">C</span></code> + without any intervention from the user. But the default <code class="computeroutput"><span class="identifier">common_type</span><span class="special"><></span></code> implementation doesn't grant that. + It is intended that clients who wish for <code class="computeroutput"><span class="identifier">common_type</span><span class="special"><</span><span class="identifier">A</span><span class="special">,</span> + <span class="identifier">B</span><span class="special">></span></code> + to be well defined to define it themselves: + </p> +<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span> +<span class="special">{</span> + +<span class="keyword">template</span> <span class="special"><></span> +<span class="keyword">struct</span> <span class="identifier">common_type</span><span class="special"><</span><span class="identifier">A</span><span class="special">,</span> <span class="identifier">B</span><span class="special">></span> <span class="special">{</span><span class="keyword">typedef</span> <span class="identifier">C</span> <span class="identifier">type</span><span class="special">;};</span> + +<span class="keyword">template</span> <span class="special"><></span> <span class="keyword">struct</span> <span class="identifier">common_type</span><span class="special"><</span><span class="identifier">B</span><span class="special">,</span> <span class="identifier">A</span><span class="special">></span> +<span class="special">:</span> <span class="keyword">public</span> <span class="identifier">common_type</span><span class="special"><</span><span class="identifier">A</span><span class="special">,</span> <span class="identifier">B</span><span class="special">></span> <span class="special">{};</span> + +<span class="special">}</span> +</pre> +<p> + Now this client can ask for <code class="computeroutput"><span class="identifier">common_type</span><span class="special"><</span><span class="identifier">A</span><span class="special">,</span> + <span class="identifier">B</span><span class="special">></span></code>. + </p> +<a name="boost_typetraits.reference.common_type.how_common_type_behaves_with_pointers_"></a><h5> +<a name="boost_typetraits.reference.common_type.how_common_type_behaves_with_pointers_-heading"></a> + <a class="link" href="common_type.html#boost_typetraits.reference.common_type.how_common_type_behaves_with_pointers_">How + common_type behaves with pointers?</a> + </h5> +<p> + Consider + </p> +<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">C</span> <span class="special">{</span> <span class="special">}:</span> +<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">:</span> <span class="identifier">C</span> <span class="special">{</span> <span class="special">};</span> +<span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">:</span> <span class="identifier">C</span> <span class="special">{</span> <span class="special">};</span> +</pre> +<p> + Shouldn't <code class="computeroutput"><span class="identifier">common_type</span><span class="special"><</span><span class="identifier">A</span><span class="special">*,</span><span class="identifier">B</span><span class="special">*>::</span><span class="identifier">type</span></code> + be <code class="computeroutput"><span class="identifier">C</span><span class="special">*</span></code>? + I would say yes, but the default implementation will make it ill-formed. + </p> +<p> + The library could add a specialization for pointers, as + </p> +<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span> +<span class="special">{</span> + + <span class="keyword">template</span> <span class="special"><</span><span class="keyword">typename</span> <span class="identifier">A</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">B</span><span class="special">></span> + <span class="keyword">struct</span> <span class="identifier">common_type</span><span class="special"><</span><span class="identifier">A</span><span class="special">*,</span> <span class="identifier">B</span><span class="special">*></span> <span class="special">{</span> + <span class="keyword">typedef</span> <span class="identifier">common_type</span><span class="special"><</span><span class="identifier">A</span><span class="special">,</span> <span class="identifier">B</span><span class="special">>*</span> <span class="identifier">type</span><span class="special">;</span> + <span class="special">};</span> +<span class="special">}</span> +</pre> +<p> + But in the absence of a motivating use cases, we prefer not to add more than + the standard specifies. + </p> +<p> + Of course the user can always make this specialization. + </p> +<a name="boost_typetraits.reference.common_type.can_you_explain_the_pros_cons_of_common_type_against_boost_typeof_"></a><h5> +<a name="boost_typetraits.reference.common_type.can_you_explain_the_pros_cons_of_common_type_against_boost_typeof_-heading"></a> + <a class="link" href="common_type.html#boost_typetraits.reference.common_type.can_you_explain_the_pros_cons_of_common_type_against_boost_typeof_">Can + you explain the pros/cons of common_type against Boost.Typeof?</a> + </h5> +<p> + Even if they appear to be close, <code class="computeroutput"><a class="link" href="common_type.html" title="common_type">common_type</a></code> + and <code class="computeroutput"><span class="identifier">typeof</span></code> have different + purposes. You use <code class="computeroutput"><span class="identifier">typeof</span></code> + to get the type of an expression, while you use <a class="link" href="common_type.html" title="common_type">common_type</a> + to set explicitly the type returned of a template function. Both are complementary, + and indeed <a class="link" href="common_type.html" title="common_type">common_type</a> + is equivalent to <code class="computeroutput"><span class="identifier">decltype</span><span class="special">(</span><a href="../../../../../utility/doc/html/declval.html" target="_top">declval</a><span class="special"><</span><span class="keyword">bool</span><span class="special">>()</span> + <span class="special">?</span> <a href="../../../../../utility/doc/html/declval.html" target="_top">declval</a><span class="special"><</span><span class="identifier">T</span><span class="special">>()</span> + <span class="special">:</span> <a href="../../../../../utility/doc/html/declval.html" target="_top">declval</a><span class="special"><</span><span class="identifier">U</span><span class="special">>())</span></code> + </p> +<p> + <a class="link" href="common_type.html" title="common_type">common_type</a> + is also similar to promote_args<class ...T> in boost/math/tools/promotion.hpp, + though it is not exactly the same as promote_args either. <a class="link" href="common_type.html" title="common_type">common_type</a><T1, + T2>::type simply represents the result of some operation on T1 and T2, + and defaults to the type obtained by putting T1 and T2 into a conditional + statement. + </p> +<p> + It is meant to be customizable (via specialization) if this default is not + appropriate. + </p> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="conditional.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="decay.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/reference/common_type_hpp.html b/libs/type_traits/doc/html/boost_typetraits/reference/common_type_hpp.html new file mode 100644 index 0000000000..52059cfccc --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/reference/common_type_hpp.html @@ -0,0 +1,117 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>common_type</title> +<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.74.0"> +<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../reference.html" title="Alphabetical Reference"> +<link rel="prev" href="alignment_of.html" title="alignment_of"> +<link rel="next" href="decay.html" title="decay"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td> +<td align="center"><a href="../../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="alignment_of.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="decay.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section" lang="en"> +<div class="titlepage"><div><div><h3 class="title"> +<a name="boost_typetraits.reference.common_type_hpp"></a><a class="link" href="common_type_hpp.html" title="common_type"> common_type</a> +</h3></div></div></div> +<p> + <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">common_type</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + </p> +<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span> + <span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="special">...</span><span class="identifier">T</span><span class="special">></span> <span class="keyword">struct</span> <a class="link" href="../../">common_type</a><span class="special">;</span> +<span class="special">}</span> +</pre> +<p> + <a class="link" href="../../">common_type</a> + is a traits class used to deduce a type common to a several types, useful + as the return type of functions operating on multiple input types such as + in mixed-mode arithmetic.. + </p> +<p> + The nested typedef <code class="computeroutput"><span class="special">::</span><span class="identifier">type</span></code> + could be defined as follows: + </p> +<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="special">...</span><span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">common_type</span><span class="special">;</span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">U</span><span class="special">,</span> <span class="keyword">class</span> <span class="special">...</span><span class="identifier">V</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">common_type</span><span class="special"><</span><span class="identifier">T</span><span class="special">,</span><span class="identifier">U</span><span class="special">,...</span><span class="identifier">V</span><span class="special">></span> <span class="special">{</span> + <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">__common_type__</span><span class="special"><</span><span class="keyword">typename</span> <span class="identifier">__common_type__</span><span class="special"><</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">U</span><span class="special">>::</span><span class="identifier">type</span><span class="special">,</span> <span class="identifier">V</span><span class="special">...>::</span><span class="identifier">type</span> <span class="identifier">type</span><span class="special">;</span> +<span class="special">};</span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">common_type</span><span class="special"><</span><span class="identifier">T</span><span class="special">></span> <span class="special">{</span> + <span class="keyword">typedef</span> <span class="identifier">T</span> <span class="identifier">type</span><span class="special">;</span> +<span class="special">};</span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">U</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">common_type</span><span class="special"><</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">U</span><span class="special">></span> <span class="special">{</span> + <span class="keyword">typedef</span> <span class="identifier">decltype</span><span class="special">(</span><span class="identifier">__declval__</span><span class="special"><</span><span class="keyword">bool</span><span class="special">>()</span> <span class="special">?</span> <span class="identifier">__declval__</span><span class="special"><</span><span class="identifier">T</span><span class="special">>()</span> <span class="special">:</span> <span class="identifier">__declval__</span><span class="special"><</span><span class="identifier">U</span><span class="special">>())</span> <span class="identifier">type</span><span class="special">;</span> +<span class="special">};</span> +</pre> +<p> + All parameter types must be complete. This trait is permitted to be specialized + by a user if at least one template parameter is a user-defined type. <span class="bold"><strong>Note:</strong></span> Such specializations are required when only + explicit conversions are desired among the <a class="link" href="../../">common_type</a> + arguments. + </p> +<a name="boost_typetraits.reference.common_type_hpp.configuration_macros"></a><h5> +<a name="id895242"></a> + <a class="link" href="common_type_hpp.html#boost_typetraits.reference.common_type_hpp.configuration_macros">Configuration + macros</a> + </h5> +<p> + When the compiler does not support static assertions then the user can select + the way static assertions are reported. Define + </p> +<div class="itemizedlist"><ul type="disc"> +<li> + BOOST_COMMON_TYPE_USES_STATIC_ASSERT: define it if you want to use Boost.StaticAssert + </li> +<li> + BOOST_COMMON_TYPE_USES_MPL_ASSERT: define it if you want to use Boost.MPL + static asertions + </li> +</ul></div> +<p> + The default behavior is to use mpl assertions in this case, but setting BOOST_COMMON_TYPE_USES_STATIC_ASSERT + may reduce compile times and header dependencies somewhat. + </p> +<p> + Depending on the static assertion used you will have an hint of the failing + assertion either through the symbol or through the text. + </p> +<p> + When possible common_type is implemented using <code class="computeroutput"><span class="identifier">decltype</span></code>. + Otherwise when BOOST_COMMON_TYPE_DONT_USE_TYPEOF is not defined it uses Boost.TypeOf. + </p> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2006 Adobe Systems Inc, David Abrahams, + Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, Jesse Jones, Mat + Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten Ottosen, Robert + Ramey and Jeremy Siek<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="alignment_of.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="decay.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/reference/conditional.html b/libs/type_traits/doc/html/boost_typetraits/reference/conditional.html new file mode 100644 index 0000000000..773e12d0ce --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/reference/conditional.html @@ -0,0 +1,63 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>conditional</title> +<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../reference.html" title="Alphabetical Reference"> +<link rel="prev" href="alignment_of.html" title="alignment_of"> +<link rel="next" href="common_type.html" title="common_type"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td> +<td align="center"><a href="../../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="alignment_of.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="common_type.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h3 class="title"> +<a name="boost_typetraits.reference.conditional"></a><a class="link" href="conditional.html" title="conditional">conditional</a> +</h3></div></div></div> +<p> + <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"> <span class="preprocessor">#include</span> + <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">conditional</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + </p> +<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span> + <span class="keyword">template</span> <span class="special"><</span><span class="keyword">bool</span> <span class="identifier">B</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">U</span><span class="special">></span> <span class="keyword">struct</span> <a class="link" href="conditional.html" title="conditional">conditional</a><span class="special">;</span> +<span class="special">}</span> +</pre> +<p> + If B is true, the member typedef type shall equal T. If B is false, the member + typedef type shall equal U. + </p> +<p> + This trait is really just an alias for <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">mpl</span><span class="special">::</span><span class="identifier">if_c</span></code>. + </p> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="alignment_of.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="common_type.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/reference/decay.html b/libs/type_traits/doc/html/boost_typetraits/reference/decay.html new file mode 100644 index 0000000000..ea5f858842 --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/reference/decay.html @@ -0,0 +1,152 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>decay</title> +<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../reference.html" title="Alphabetical Reference"> +<link rel="prev" href="common_type.html" title="common_type"> +<link rel="next" href="extent.html" title="extent"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td> +<td align="center"><a href="../../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="common_type.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="extent.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h3 class="title"> +<a name="boost_typetraits.reference.decay"></a><a class="link" href="decay.html" title="decay">decay</a> +</h3></div></div></div> +<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">decay</span> +<span class="special">{</span> + <span class="keyword">typedef</span> <em class="replaceable"><code>see-below</code></em> <span class="identifier">type</span><span class="special">;</span> +<span class="special">};</span> +</pre> +<p> + <span class="bold"><strong>type:</strong></span> Let <code class="computeroutput"><span class="identifier">U</span></code> + be the result of <code class="computeroutput"><span class="identifier">remove_reference</span><span class="special"><</span><span class="identifier">T</span><span class="special">>::</span><span class="identifier">type</span></code>, then if <code class="computeroutput"><span class="identifier">U</span></code> + is an array type, the result is <code class="computeroutput"><span class="identifier">remove_extent</span><span class="special"><</span><span class="identifier">U</span><span class="special">>::</span><span class="identifier">type</span><span class="special">*</span></code>, + otherwise if <code class="computeroutput"><span class="identifier">U</span></code> is a function + type then the result is <code class="computeroutput"><span class="identifier">U</span><span class="special">*</span></code>, otherwise the result is <code class="computeroutput"><span class="identifier">U</span></code>. + </p> +<p> + <span class="bold"><strong>C++ Standard Reference:</strong></span> 3.9.1. + </p> +<p> + <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"> <span class="preprocessor">#include</span> + <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">decay</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + </p> +<div class="table"> +<a name="boost_typetraits.reference.decay.examples"></a><p class="title"><b>Table 1.17. Examples</b></p> +<div class="table-contents"><table class="table" summary="Examples"> +<colgroup> +<col> +<col> +</colgroup> +<thead><tr> +<th> + <p> + Expression + </p> + </th> +<th> + <p> + Result Type + </p> + </th> +</tr></thead> +<tbody> +<tr> +<td> + <p> + <code class="computeroutput"><span class="identifier">decay</span><span class="special"><</span><span class="keyword">int</span><span class="special">[</span><span class="number">2</span><span class="special">][</span><span class="number">3</span><span class="special">]>::</span><span class="identifier">type</span></code> + </p> + </td> +<td> + <p> + <code class="computeroutput"><span class="keyword">int</span><span class="special">[</span><span class="number">3</span><span class="special">]*</span></code> + </p> + </td> +</tr> +<tr> +<td> + <p> + <code class="computeroutput"><span class="identifier">decay</span><span class="special"><</span><span class="keyword">int</span><span class="special">(&)[</span><span class="number">2</span><span class="special">]>::</span><span class="identifier">type</span></code> + </p> + </td> +<td> + <p> + <code class="computeroutput"><span class="keyword">int</span><span class="special">*</span></code> + </p> + </td> +</tr> +<tr> +<td> + <p> + <code class="computeroutput"><span class="identifier">decay</span><span class="special"><</span><span class="keyword">int</span><span class="special">(&)(</span><span class="keyword">double</span><span class="special">)>::</span><span class="identifier">type</span></code> + </p> + </td> +<td> + <p> + <code class="computeroutput"><span class="keyword">int</span><span class="special">(*)(</span><span class="keyword">double</span><span class="special">)</span></code> + </p> + </td> +</tr> +<tr> +<td> + <p> + <code class="computeroutput"><span class="keyword">int</span><span class="special">(*)(</span><span class="keyword">double</span></code> + </p> + </td> +<td> + <p> + <code class="computeroutput"><span class="keyword">int</span><span class="special">(*)(</span><span class="keyword">double</span><span class="special">)</span></code> + </p> + </td> +</tr> +<tr> +<td> + <p> + <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="keyword">double</span><span class="special">)</span></code> + </p> + </td> +<td> + <p> + <code class="computeroutput"><span class="keyword">int</span><span class="special">(*)(</span><span class="keyword">double</span><span class="special">)</span></code> + </p> + </td> +</tr> +</tbody> +</table></div> +</div> +<br class="table-break"> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="common_type.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="extent.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/reference/extent.html b/libs/type_traits/doc/html/boost_typetraits/reference/extent.html new file mode 100644 index 0000000000..6165ae528d --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/reference/extent.html @@ -0,0 +1,109 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>extent</title> +<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../reference.html" title="Alphabetical Reference"> +<link rel="prev" href="decay.html" title="decay"> +<link rel="next" href="floating_point_promotion.html" title="floating_point_promotion"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td> +<td align="center"><a href="../../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="decay.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="floating_point_promotion.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h3 class="title"> +<a name="boost_typetraits.reference.extent"></a><a class="link" href="extent.html" title="extent">extent</a> +</h3></div></div></div> +<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">N</span> <span class="special">=</span> <span class="number">0</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">extent</span> <span class="special">:</span> <span class="keyword">public</span> <a class="link" href="integral_constant.html" title="integral_constant">integral_constant</a><span class="special"><</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span><span class="special">,</span> <span class="identifier">EXTENT</span><span class="special">(</span><span class="identifier">T</span><span class="special">,</span><span class="identifier">N</span><span class="special">)></span> <span class="special">{};</span> +</pre> +<p> + <span class="bold"><strong>Inherits:</strong></span> Class template extent inherits + from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">integral_constant</a><span class="special"><</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span><span class="special">,</span> <span class="identifier">EXTENT</span><span class="special">(</span><span class="identifier">T</span><span class="special">,</span><span class="identifier">N</span><span class="special">)></span></code>, + where <code class="computeroutput"><span class="identifier">EXTENT</span><span class="special">(</span><span class="identifier">T</span><span class="special">,</span><span class="identifier">N</span><span class="special">)</span></code> is the number of elements in the N'th array + dimension of type <code class="computeroutput"><span class="identifier">T</span></code>. + </p> +<p> + If <code class="computeroutput"><span class="identifier">T</span></code> is not a (built-in) + array type, or if <code class="computeroutput"><span class="identifier">N</span> <span class="special">></span> + <a class="link" href="rank.html" title="rank">rank</a><span class="special"><</span><span class="identifier">T</span><span class="special">>::</span><span class="identifier">value</span></code>, or if the N'th array bound is incomplete, + then <code class="computeroutput"><span class="identifier">EXTENT</span><span class="special">(</span><span class="identifier">T</span><span class="special">,</span><span class="identifier">N</span><span class="special">)</span></code> is zero. + </p> +<p> + <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"> <span class="preprocessor">#include</span> + <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">extent</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + </p> +<p> + <span class="bold"><strong>Examples:</strong></span> + </p> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">extent</span><span class="special"><</span><span class="keyword">int</span><span class="special">[</span><span class="number">1</span><span class="special">]></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">integral_constant</a><span class="special"><</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span><span class="special">,</span> <span class="number">1</span><span class="special">></span></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">extent</span><span class="special"><</span><span class="keyword">double</span><span class="special">[</span><span class="number">2</span><span class="special">][</span><span class="number">3</span><span class="special">][</span><span class="number">4</span><span class="special">],</span> + <span class="number">0</span><span class="special">>::</span><span class="identifier">type</span></code> is the type <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">integral_constant</a><span class="special"><</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span><span class="special">,</span> <span class="number">2</span><span class="special">></span></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">extent</span><span class="special"><</span><span class="keyword">double</span><span class="special">[</span><span class="number">2</span><span class="special">][</span><span class="number">3</span><span class="special">][</span><span class="number">4</span><span class="special">],</span> + <span class="number">1</span><span class="special">>::</span><span class="identifier">type</span></code> is the type <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">integral_constant</a><span class="special"><</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span><span class="special">,</span> <span class="number">3</span><span class="special">></span></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">extent</span><span class="special"><</span><span class="keyword">double</span><span class="special">[</span><span class="number">2</span><span class="special">][</span><span class="number">3</span><span class="special">][</span><span class="number">4</span><span class="special">],</span> + <span class="number">3</span><span class="special">>::</span><span class="identifier">type</span></code> is the type <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">integral_constant</a><span class="special"><</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span><span class="special">,</span> <span class="number">4</span><span class="special">></span></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">extent</span><span class="special"><</span><span class="keyword">int</span><span class="special">[</span><span class="number">4</span><span class="special">]>::</span><span class="identifier">value</span></code> + is an integral constant expression that evaluates to <span class="emphasis"><em>4</em></span>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">extent</span><span class="special"><</span><span class="keyword">int</span><span class="special">[][</span><span class="number">2</span><span class="special">]>::</span><span class="identifier">value</span></code> + is an integral constant expression that evaluates to <span class="emphasis"><em>0</em></span>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">extent</span><span class="special"><</span><span class="keyword">int</span><span class="special">[][</span><span class="number">2</span><span class="special">],</span> <span class="number">1</span><span class="special">>::</span><span class="identifier">value</span></code> is an integral constant expression + that evaluates to <span class="emphasis"><em>2</em></span>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">extent</span><span class="special"><</span><span class="keyword">int</span><span class="special">*>::</span><span class="identifier">value</span></code> is an integral constant expression + that evaluates to <span class="emphasis"><em>0</em></span>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">extent</span><span class="special"><</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">array</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="number">3</span><span class="special">></span> <span class="special">>::</span><span class="identifier">value</span></code> is an integral constant expression + that evaluates to <span class="emphasis"><em>0</em></span>: <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">array</span></code> + is a class type and <span class="bold"><strong>not an array type</strong></span>! + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">extent</span><span class="special"><</span><span class="identifier">T</span><span class="special">>::</span><span class="identifier">value_type</span></code> is the type <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span></code>. + </p></blockquote></div> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="decay.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="floating_point_promotion.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/reference/floating_point_promotion.html b/libs/type_traits/doc/html/boost_typetraits/reference/floating_point_promotion.html new file mode 100644 index 0000000000..f96108e152 --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/reference/floating_point_promotion.html @@ -0,0 +1,129 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>floating_point_promotion</title> +<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../reference.html" title="Alphabetical Reference"> +<link rel="prev" href="extent.html" title="extent"> +<link rel="next" href="function_traits.html" title="function_traits"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td> +<td align="center"><a href="../../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="extent.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="function_traits.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h3 class="title"> +<a name="boost_typetraits.reference.floating_point_promotion"></a><a class="link" href="floating_point_promotion.html" title="floating_point_promotion">floating_point_promotion</a> +</h3></div></div></div> +<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">floating_point_promotion</span> +<span class="special">{</span> + <span class="keyword">typedef</span> <em class="replaceable"><code>see-below</code></em> <span class="identifier">type</span><span class="special">;</span> +<span class="special">};</span> +</pre> +<p> + <span class="bold"><strong>type:</strong></span> If floating point promotion can be + applied to an rvalue of type <code class="computeroutput"><span class="identifier">T</span></code>, + then applies floating point promotion to <code class="computeroutput"><span class="identifier">T</span></code> + and keeps cv-qualifiers of <code class="computeroutput"><span class="identifier">T</span></code>, + otherwise leaves <code class="computeroutput"><span class="identifier">T</span></code> unchanged. + </p> +<p> + <span class="bold"><strong>C++ Standard Reference:</strong></span> 4.6. + </p> +<p> + <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"> <span class="preprocessor">#include</span> + <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">floating_point_promotion</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + </p> +<div class="table"> +<a name="boost_typetraits.reference.floating_point_promotion.examples"></a><p class="title"><b>Table 1.18. Examples</b></p> +<div class="table-contents"><table class="table" summary="Examples"> +<colgroup> +<col> +<col> +</colgroup> +<thead><tr> +<th> + <p> + Expression + </p> + </th> +<th> + <p> + Result Type + </p> + </th> +</tr></thead> +<tbody> +<tr> +<td> + <p> + <code class="computeroutput"><span class="identifier">floating_point_promotion</span><span class="special"><</span><span class="keyword">float</span> + <span class="keyword">const</span><span class="special">>::</span><span class="identifier">type</span></code> + </p> + </td> +<td> + <p> + <code class="computeroutput"><span class="keyword">double</span> <span class="keyword">const</span></code> + </p> + </td> +</tr> +<tr> +<td> + <p> + <code class="computeroutput"><span class="identifier">floating_point_promotion</span><span class="special"><</span><span class="keyword">float</span><span class="special">&>::</span><span class="identifier">type</span></code> + </p> + </td> +<td> + <p> + <code class="computeroutput"><span class="keyword">float</span><span class="special">&</span></code> + </p> + </td> +</tr> +<tr> +<td> + <p> + <code class="computeroutput"><span class="identifier">floating_point_promotion</span><span class="special"><</span><span class="keyword">short</span><span class="special">>::</span><span class="identifier">type</span></code> + </p> + </td> +<td> + <p> + <code class="computeroutput"><span class="keyword">short</span></code> + </p> + </td> +</tr> +</tbody> +</table></div> +</div> +<br class="table-break"> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="extent.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="function_traits.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/reference/function_traits.html b/libs/type_traits/doc/html/boost_typetraits/reference/function_traits.html new file mode 100644 index 0000000000..413eef0fbf --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/reference/function_traits.html @@ -0,0 +1,285 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>function_traits</title> +<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../reference.html" title="Alphabetical Reference"> +<link rel="prev" href="floating_point_promotion.html" title="floating_point_promotion"> +<link rel="next" href="has_bit_and.html" title="has_bit_and"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td> +<td align="center"><a href="../../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="floating_point_promotion.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="has_bit_and.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h3 class="title"> +<a name="boost_typetraits.reference.function_traits"></a><a class="link" href="function_traits.html" title="function_traits">function_traits</a> +</h3></div></div></div> +<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">F</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">function_traits</span> +<span class="special">{</span> + <span class="keyword">static</span> <span class="keyword">const</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">arity</span> <span class="special">=</span> <em class="replaceable"><code>see-below</code></em><span class="special">;</span> + <span class="keyword">typedef</span> <em class="replaceable"><code>see-below</code></em> <span class="identifier">result_type</span><span class="special">;</span> + <span class="keyword">typedef</span> <em class="replaceable"><code>see-below</code></em> arg<em class="replaceable"><code>N</code></em>_type<span class="special">;</span> +<span class="special">};</span> +</pre> +<p> + The class template function_traits will only compile if: + </p> +<div class="itemizedlist"><ul class="itemizedlist" type="disc"> +<li class="listitem"> + The compiler supports partial specialization of class templates. + </li> +<li class="listitem"> + The template argument <code class="computeroutput"><span class="identifier">F</span></code> + is a <span class="emphasis"><em>function type</em></span>, note that this <span class="emphasis"><em><span class="bold"><strong>is not</strong></span></em></span> the same thing as a <span class="emphasis"><em>pointer + to a function</em></span>. + </li> +</ul></div> +<div class="tip"><table border="0" summary="Tip"> +<tr> +<td rowspan="2" align="center" valign="top" width="25"><img alt="[Tip]" src="../../../../../../doc/src/images/tip.png"></td> +<th align="left">Tip</th> +</tr> +<tr><td align="left" valign="top"><p> + 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 <a class="link" href="remove_pointer.html" title="remove_pointer">remove_pointer</a>. + </p></td></tr> +</table></div> +<div class="table"> +<a name="boost_typetraits.reference.function_traits.function_traits_members"></a><p class="title"><b>Table 1.19. Function Traits Members</b></p> +<div class="table-contents"><table class="table" summary="Function Traits Members"> +<colgroup> +<col> +<col> +</colgroup> +<thead><tr> +<th> + <p> + Member + </p> + </th> +<th> + <p> + Description + </p> + </th> +</tr></thead> +<tbody> +<tr> +<td> + <p> + <code class="computeroutput"><span class="identifier">function_traits</span><span class="special"><</span><span class="identifier">F</span><span class="special">>::</span><span class="identifier">arity</span></code> + </p> + </td> +<td> + <p> + An integral constant expression that gives the number of arguments + accepted by the function type <code class="computeroutput"><span class="identifier">F</span></code>. + </p> + </td> +</tr> +<tr> +<td> + <p> + <code class="computeroutput"><span class="identifier">function_traits</span><span class="special"><</span><span class="identifier">F</span><span class="special">>::</span><span class="identifier">result_type</span></code> + </p> + </td> +<td> + <p> + The type returned by function type <code class="computeroutput"><span class="identifier">F</span></code>. + </p> + </td> +</tr> +<tr> +<td> + <p> + <code class="computeroutput"><span class="identifier">function_traits</span><span class="special"><</span><span class="identifier">F</span><span class="special">>::</span>arg<em class="replaceable"><code>N</code></em>_type</code> + </p> + </td> +<td> + <p> + The <em class="replaceable"><code>N</code></em>th argument type of function type <code class="computeroutput"><span class="identifier">F</span></code>, + where <code class="computeroutput"><span class="number">1</span> <span class="special"><=</span> + <span class="identifier">N</span> <span class="special"><=</span> + <span class="identifier">arity</span></code> of <code class="computeroutput"><span class="identifier">F</span></code>. + </p> + </td> +</tr> +</tbody> +</table></div> +</div> +<br class="table-break"><div class="table"> +<a name="boost_typetraits.reference.function_traits.examples"></a><p class="title"><b>Table 1.20. Examples</b></p> +<div class="table-contents"><table class="table" summary="Examples"> +<colgroup> +<col> +<col> +</colgroup> +<thead><tr> +<th> + <p> + Expression + </p> + </th> +<th> + <p> + Result + </p> + </th> +</tr></thead> +<tbody> +<tr> +<td> + <p> + <code class="computeroutput"><span class="identifier">function_traits</span><span class="special"><</span><span class="keyword">void</span> + <span class="special">(</span><span class="keyword">void</span><span class="special">)>::</span><span class="identifier">arity</span></code> + </p> + </td> +<td> + <p> + An integral constant expression that has the value 0. + </p> + </td> +</tr> +<tr> +<td> + <p> + <code class="computeroutput"><span class="identifier">function_traits</span><span class="special"><</span><span class="keyword">long</span> + <span class="special">(</span><span class="keyword">int</span><span class="special">)>::</span><span class="identifier">arity</span></code> + </p> + </td> +<td> + <p> + An integral constant expression that has the value 1. + </p> + </td> +</tr> +<tr> +<td> + <p> + <code class="computeroutput"><span class="identifier">function_traits</span><span class="special"><</span><span class="keyword">long</span> + <span class="special">(</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">long</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">void</span><span class="special">*)>::</span><span class="identifier">arity</span></code> + </p> + </td> +<td> + <p> + An integral constant expression that has the value 4. + </p> + </td> +</tr> +<tr> +<td> + <p> + <code class="computeroutput"><span class="identifier">function_traits</span><span class="special"><</span><span class="keyword">void</span> + <span class="special">(</span><span class="keyword">void</span><span class="special">)>::</span><span class="identifier">result_type</span></code> + </p> + </td> +<td> + <p> + The type <code class="computeroutput"><span class="keyword">void</span></code>. + </p> + </td> +</tr> +<tr> +<td> + <p> + <code class="computeroutput"><span class="identifier">function_traits</span><span class="special"><</span><span class="keyword">long</span> + <span class="special">(</span><span class="keyword">int</span><span class="special">)>::</span><span class="identifier">result_type</span></code> + </p> + </td> +<td> + <p> + The type <code class="computeroutput"><span class="keyword">long</span></code>. + </p> + </td> +</tr> +<tr> +<td> + <p> + <code class="computeroutput"><span class="identifier">function_traits</span><span class="special"><</span><span class="keyword">long</span> + <span class="special">(</span><span class="keyword">int</span><span class="special">)>::</span><span class="identifier">arg1_type</span></code> + </p> + </td> +<td> + <p> + The type <code class="computeroutput"><span class="keyword">int</span></code>. + </p> + </td> +</tr> +<tr> +<td> + <p> + <code class="computeroutput"><span class="identifier">function_traits</span><span class="special"><</span><span class="keyword">long</span> + <span class="special">(</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">long</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">void</span><span class="special">*)>::</span><span class="identifier">arg4_type</span></code> + </p> + </td> +<td> + <p> + The type <code class="computeroutput"><span class="keyword">void</span><span class="special">*</span></code>. + </p> + </td> +</tr> +<tr> +<td> + <p> + <code class="computeroutput"><span class="identifier">function_traits</span><span class="special"><</span><span class="keyword">long</span> + <span class="special">(</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">long</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">void</span><span class="special">*)>::</span><span class="identifier">arg5_type</span></code> + </p> + </td> +<td> + <p> + A compiler error: there is no <code class="computeroutput"><span class="identifier">arg5_type</span></code> + since there are only four arguments. + </p> + </td> +</tr> +<tr> +<td> + <p> + <code class="computeroutput"><span class="identifier">function_traits</span><span class="special"><</span><span class="keyword">long</span> + <span class="special">(*)(</span><span class="keyword">void</span><span class="special">)>::</span><span class="identifier">arity</span></code> + </p> + </td> +<td> + <p> + A compiler error: argument type is a <span class="emphasis"><em>function pointer</em></span>, + and not a <span class="emphasis"><em>function type</em></span>. + </p> + </td> +</tr> +</tbody> +</table></div> +</div> +<br class="table-break"> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="floating_point_promotion.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="has_bit_and.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/reference/has_bit_and.html b/libs/type_traits/doc/html/boost_typetraits/reference/has_bit_and.html new file mode 100644 index 0000000000..aa501d4a07 --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/reference/has_bit_and.html @@ -0,0 +1,192 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>has_bit_and</title> +<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../reference.html" title="Alphabetical Reference"> +<link rel="prev" href="function_traits.html" title="function_traits"> +<link rel="next" href="has_bit_and_assign.html" title="has_bit_and_assign"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td> +<td align="center"><a href="../../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="function_traits.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="has_bit_and_assign.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h3 class="title"> +<a name="boost_typetraits.reference.has_bit_and"></a><a class="link" href="has_bit_and.html" title="has_bit_and">has_bit_and</a> +</h3></div></div></div> +<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">Lhs</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Rhs</span><span class="special">=</span><span class="identifier">Lhs</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Ret</span><span class="special">=</span><span class="identifier">dont_care</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">has_bit_and</span> <span class="special">:</span> <span class="keyword">public</span> <em class="replaceable"><code><a class="link" href="integral_constant.html" title="integral_constant">true_type</a>-or-<a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code></em> <span class="special">{};</span> +</pre> +<p> + <span class="bold"><strong>Inherits:</strong></span> If (i) <code class="computeroutput"><span class="identifier">lhs</span></code> + of type <code class="computeroutput"><span class="identifier">Lhs</span></code> and <code class="computeroutput"><span class="identifier">rhs</span></code> of type <code class="computeroutput"><span class="identifier">Rhs</span></code> + can be used in expression <code class="computeroutput"><span class="identifier">lhs</span><span class="special">&</span><span class="identifier">rhs</span></code>, + and (ii) <code class="computeroutput"><span class="identifier">Ret</span><span class="special">=</span><span class="identifier">dont_care</span></code> or the result of expression + <code class="computeroutput"><span class="identifier">lhs</span><span class="special">&</span><span class="identifier">rhs</span></code> is convertible to <code class="computeroutput"><span class="identifier">Ret</span></code> + then inherits from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>, + otherwise inherits from <a class="link" href="integral_constant.html" title="integral_constant">false_type</a>. + </p> +<p> + The default behaviour (<code class="computeroutput"><span class="identifier">Ret</span><span class="special">=</span><span class="identifier">dont_care</span></code>) + is to not check for the return value of binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">&</span></code>. If <code class="computeroutput"><span class="identifier">Ret</span></code> + is different from the default <code class="computeroutput"><span class="identifier">dont_care</span></code> + type, the return value is checked to be convertible to <code class="computeroutput"><span class="identifier">Ret</span></code>. + Convertible to <code class="computeroutput"><span class="identifier">Ret</span></code> means + that the return value of the operator can be used as argument to a function + expecting <code class="computeroutput"><span class="identifier">Ret</span></code>: +</p> +<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">Ret</span><span class="special">);</span> +<span class="identifier">Lhs</span> <span class="identifier">lhs</span><span class="special">;</span> +<span class="identifier">Rhs</span> <span class="identifier">rhs</span><span class="special">;</span> +<span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">&</span><span class="identifier">rhs</span><span class="special">);</span> <span class="comment">// is valid if has_bit_and<Lhs, Rhs, Ret>::value==true</span> +</pre> +<p> + If <code class="computeroutput"><span class="identifier">Ret</span><span class="special">=</span><span class="keyword">void</span></code>, the return type is checked to be exactly + <code class="computeroutput"><span class="keyword">void</span></code>. + </p> +<p> + <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"><span class="preprocessor">#include</span> + <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_bit_and</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_operator</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + </p> +<p> + <span class="bold"><strong>Examples:</strong></span> + </p> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_bit_and</span><span class="special"><</span><span class="identifier">Lhs</span><span class="special">,</span> <span class="identifier">Rhs</span><span class="special">,</span> <span class="identifier">Ret</span><span class="special">>::</span><span class="identifier">value_type</span></code> is the type <code class="computeroutput"><span class="keyword">bool</span></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_bit_and</span><span class="special"><</span><span class="identifier">Lhs</span><span class="special">,</span> <span class="identifier">Rhs</span><span class="special">,</span> <span class="identifier">Ret</span><span class="special">>::</span><span class="identifier">value</span></code> is a <code class="computeroutput"><span class="keyword">bool</span></code> + integral constant expression. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_bit_and</span><span class="special"><</span><span class="keyword">int</span><span class="special">>::</span><span class="identifier">value</span></code> is a <code class="computeroutput"><span class="keyword">bool</span></code> + integral constant expression that evaluates to <code class="computeroutput"><span class="keyword">true</span></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_bit_and</span><span class="special"><</span><span class="keyword">long</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_bit_and</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_bit_and</span><span class="special"><</span><span class="keyword">const</span> <span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_bit_and</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">bool</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_bit_and</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>. + </p></blockquote></div> +<p> + <span class="bold"><strong>See also:</strong></span> <a class="link" href="../category/value_traits/operators.html" title="Operator Type Traits">Operator + Type Traits</a> + </p> +<p> + <span class="bold"><strong>Limitation:</strong></span> + </p> +<div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"> + Requires a compiler with working SFINAE. + </li></ul></div> +<p> + <span class="bold"><strong>Known issues:</strong></span> + </p> +<div class="itemizedlist"><ul class="itemizedlist" type="disc"> +<li class="listitem"> + This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">&</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">&</span></code> + is defined as a private member of <code class="computeroutput"><span class="identifier">Lhs</span></code> + then instantiating <code class="computeroutput"><span class="identifier">has_bit_and</span><span class="special"><</span><span class="identifier">Lhs</span><span class="special">></span></code> will produce a compiler error. For + this reason <code class="computeroutput"><span class="identifier">has_bit_and</span></code> + cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">&</span></code> + or not. +<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">&(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&);</span> <span class="special">};</span> +<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_bit_and</span><span class="special"><</span><span class="identifier">A</span><span class="special">>::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator&(const A&) is private</span> +</pre> + </li> +<li class="listitem"> + There is an issue if the operator exists only for type <code class="computeroutput"><span class="identifier">A</span></code> and <code class="computeroutput"><span class="identifier">B</span></code> + is convertible to <code class="computeroutput"><span class="identifier">A</span></code>. + In this case, the compiler will report an ambiguous overload. +<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span> +<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">&(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&,</span> <span class="keyword">const</span> <span class="identifier">A</span><span class="special">&);</span> +<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span> +<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_bit_and</span><span class="special"><</span><span class="identifier">A</span><span class="special">>::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine</span> +<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_bit_and</span><span class="special"><</span><span class="identifier">B</span><span class="special">>::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambiguous overload</span> +</pre> + </li> +<li class="listitem"> + There is an issue when applying this trait to template classes. If <code class="computeroutput"><span class="keyword">operator</span><span class="special">&</span></code> + is defined but does not bind for a given template type, it is still detected + by the trait which returns <code class="computeroutput"><span class="keyword">true</span></code> + instead of <code class="computeroutput"><span class="keyword">false</span></code>. Example: + +<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_bit_and</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span> +<span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">iostream</span><span class="special">></span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">contains</span> <span class="special">{</span> <span class="identifier">T</span> <span class="identifier">data</span><span class="special">;</span> <span class="special">};</span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">&(</span><span class="keyword">const</span> <span class="identifier">contains</span><span class="special"><</span><span class="identifier">T</span><span class="special">></span> <span class="special">&</span><span class="identifier">lhs</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">contains</span><span class="special"><</span><span class="identifier">T</span><span class="special">></span> <span class="special">&</span><span class="identifier">rhs</span><span class="special">)</span> <span class="special">{</span> + <span class="keyword">return</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">,</span> <span class="identifier">rhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">);</span> +<span class="special">}</span> + +<span class="keyword">class</span> <span class="identifier">bad</span> <span class="special">{</span> <span class="special">};</span> +<span class="keyword">class</span> <span class="identifier">good</span> <span class="special">{</span> <span class="special">};</span> +<span class="keyword">bool</span> <span class="identifier">f</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">good</span><span class="special">&,</span> <span class="keyword">const</span> <span class="identifier">good</span><span class="special">&)</span> <span class="special">{</span> <span class="special">}</span> + +<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span> <span class="special">{</span> + <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special"><<</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">boolalpha</span><span class="special">;</span> + <span class="comment">// works fine for contains<good></span> + <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special"><<</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_bit_and</span><span class="special"><</span> <span class="identifier">contains</span><span class="special"><</span> <span class="identifier">good</span> <span class="special">></span> <span class="special">>::</span><span class="identifier">value</span><span class="special"><<</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true</span> + <span class="identifier">contains</span><span class="special"><</span><span class="identifier">good</span><span class="special">></span> <span class="identifier">g</span><span class="special">;</span> + <span class="identifier">g</span><span class="special">&</span><span class="identifier">g</span><span class="special">;</span> <span class="comment">// ok</span> + <span class="comment">// does not work for contains<bad></span> + <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special"><<</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_bit_and</span><span class="special"><</span> <span class="identifier">contains</span><span class="special"><</span> <span class="identifier">bad</span> <span class="special">></span> <span class="special">>::</span><span class="identifier">value</span><span class="special"><<</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true, should be false</span> + <span class="identifier">contains</span><span class="special"><</span><span class="identifier">bad</span><span class="special">></span> <span class="identifier">b</span><span class="special">;</span> + <span class="identifier">b</span><span class="special">&</span><span class="identifier">b</span><span class="special">;</span> <span class="comment">// compile time error</span> + <span class="keyword">return</span> <span class="number">0</span><span class="special">;</span> +<span class="special">}</span> +</pre> + </li> +<li class="listitem"> + <code class="computeroutput"><span class="keyword">volatile</span></code> qualifier is not + properly handled and would lead to undefined behavior + </li> +</ul></div> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="function_traits.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="has_bit_and_assign.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/reference/has_bit_and_assign.html b/libs/type_traits/doc/html/boost_typetraits/reference/has_bit_and_assign.html new file mode 100644 index 0000000000..58b29e95d4 --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/reference/has_bit_and_assign.html @@ -0,0 +1,192 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>has_bit_and_assign</title> +<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../reference.html" title="Alphabetical Reference"> +<link rel="prev" href="has_bit_and.html" title="has_bit_and"> +<link rel="next" href="has_bit_or.html" title="has_bit_or"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td> +<td align="center"><a href="../../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="has_bit_and.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="has_bit_or.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h3 class="title"> +<a name="boost_typetraits.reference.has_bit_and_assign"></a><a class="link" href="has_bit_and_assign.html" title="has_bit_and_assign">has_bit_and_assign</a> +</h3></div></div></div> +<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">Lhs</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Rhs</span><span class="special">=</span><span class="identifier">Lhs</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Ret</span><span class="special">=</span><span class="identifier">dont_care</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">has_bit_and_assign</span> <span class="special">:</span> <span class="keyword">public</span> <em class="replaceable"><code><a class="link" href="integral_constant.html" title="integral_constant">true_type</a>-or-<a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code></em> <span class="special">{};</span> +</pre> +<p> + <span class="bold"><strong>Inherits:</strong></span> If (i) <code class="computeroutput"><span class="identifier">lhs</span></code> + of type <code class="computeroutput"><span class="identifier">Lhs</span></code> and <code class="computeroutput"><span class="identifier">rhs</span></code> of type <code class="computeroutput"><span class="identifier">Rhs</span></code> + can be used in expression <code class="computeroutput"><span class="identifier">lhs</span><span class="special">&=</span><span class="identifier">rhs</span></code>, + and (ii) <code class="computeroutput"><span class="identifier">Ret</span><span class="special">=</span><span class="identifier">dont_care</span></code> or the result of expression + <code class="computeroutput"><span class="identifier">lhs</span><span class="special">&=</span><span class="identifier">rhs</span></code> is convertible to <code class="computeroutput"><span class="identifier">Ret</span></code> + then inherits from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>, + otherwise inherits from <a class="link" href="integral_constant.html" title="integral_constant">false_type</a>. + </p> +<p> + The default behaviour (<code class="computeroutput"><span class="identifier">Ret</span><span class="special">=</span><span class="identifier">dont_care</span></code>) + is to not check for the return value of binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">&=</span></code>. If <code class="computeroutput"><span class="identifier">Ret</span></code> + is different from the default <code class="computeroutput"><span class="identifier">dont_care</span></code> + type, the return value is checked to be convertible to <code class="computeroutput"><span class="identifier">Ret</span></code>. + Convertible to <code class="computeroutput"><span class="identifier">Ret</span></code> means + that the return value of the operator can be used as argument to a function + expecting <code class="computeroutput"><span class="identifier">Ret</span></code>: +</p> +<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">Ret</span><span class="special">);</span> +<span class="identifier">Lhs</span> <span class="identifier">lhs</span><span class="special">;</span> +<span class="identifier">Rhs</span> <span class="identifier">rhs</span><span class="special">;</span> +<span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">&=</span><span class="identifier">rhs</span><span class="special">);</span> <span class="comment">// is valid if has_bit_and_assign<Lhs, Rhs, Ret>::value==true</span> +</pre> +<p> + If <code class="computeroutput"><span class="identifier">Ret</span><span class="special">=</span><span class="keyword">void</span></code>, the return type is checked to be exactly + <code class="computeroutput"><span class="keyword">void</span></code>. + </p> +<p> + <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"><span class="preprocessor">#include</span> + <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_bit_and_assign</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_operator</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + </p> +<p> + <span class="bold"><strong>Examples:</strong></span> + </p> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_bit_and_assign</span><span class="special"><</span><span class="identifier">Lhs</span><span class="special">,</span> <span class="identifier">Rhs</span><span class="special">,</span> <span class="identifier">Ret</span><span class="special">>::</span><span class="identifier">value_type</span></code> is the type <code class="computeroutput"><span class="keyword">bool</span></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_bit_and_assign</span><span class="special"><</span><span class="identifier">Lhs</span><span class="special">,</span> <span class="identifier">Rhs</span><span class="special">,</span> <span class="identifier">Ret</span><span class="special">>::</span><span class="identifier">value</span></code> is a <code class="computeroutput"><span class="keyword">bool</span></code> + integral constant expression. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_bit_and_assign</span><span class="special"><</span><span class="keyword">int</span><span class="special">>::</span><span class="identifier">value</span></code> is a <code class="computeroutput"><span class="keyword">bool</span></code> + integral constant expression that evaluates to <code class="computeroutput"><span class="keyword">true</span></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_bit_and_assign</span><span class="special"><</span><span class="keyword">long</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_bit_and_assign</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_bit_and_assign</span><span class="special"><</span><span class="keyword">const</span> <span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_bit_and_assign</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">bool</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_bit_and_assign</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>. + </p></blockquote></div> +<p> + <span class="bold"><strong>See also:</strong></span> <a class="link" href="../category/value_traits/operators.html" title="Operator Type Traits">Operator + Type Traits</a> + </p> +<p> + <span class="bold"><strong>Limitation:</strong></span> + </p> +<div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"> + Requires a compiler with working SFINAE. + </li></ul></div> +<p> + <span class="bold"><strong>Known issues:</strong></span> + </p> +<div class="itemizedlist"><ul class="itemizedlist" type="disc"> +<li class="listitem"> + This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">&=</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">&=</span></code> + is defined as a private member of <code class="computeroutput"><span class="identifier">Lhs</span></code> + then instantiating <code class="computeroutput"><span class="identifier">has_bit_and_assign</span><span class="special"><</span><span class="identifier">Lhs</span><span class="special">></span></code> will produce a compiler error. For + this reason <code class="computeroutput"><span class="identifier">has_bit_and_assign</span></code> + cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">&=</span></code> + or not. +<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">&=(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&);</span> <span class="special">};</span> +<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_bit_and_assign</span><span class="special"><</span><span class="identifier">A</span><span class="special">>::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator&=(const A&) is private</span> +</pre> + </li> +<li class="listitem"> + There is an issue if the operator exists only for type <code class="computeroutput"><span class="identifier">A</span></code> and <code class="computeroutput"><span class="identifier">B</span></code> + is convertible to <code class="computeroutput"><span class="identifier">A</span></code>. + In this case, the compiler will report an ambiguous overload. +<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span> +<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">&=(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&,</span> <span class="keyword">const</span> <span class="identifier">A</span><span class="special">&);</span> +<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span> +<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_bit_and_assign</span><span class="special"><</span><span class="identifier">A</span><span class="special">>::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine</span> +<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_bit_and_assign</span><span class="special"><</span><span class="identifier">B</span><span class="special">>::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambiguous overload</span> +</pre> + </li> +<li class="listitem"> + There is an issue when applying this trait to template classes. If <code class="computeroutput"><span class="keyword">operator</span><span class="special">&=</span></code> + is defined but does not bind for a given template type, it is still detected + by the trait which returns <code class="computeroutput"><span class="keyword">true</span></code> + instead of <code class="computeroutput"><span class="keyword">false</span></code>. Example: + +<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_bit_and_assign</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span> +<span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">iostream</span><span class="special">></span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">contains</span> <span class="special">{</span> <span class="identifier">T</span> <span class="identifier">data</span><span class="special">;</span> <span class="special">};</span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">&=(</span><span class="keyword">const</span> <span class="identifier">contains</span><span class="special"><</span><span class="identifier">T</span><span class="special">></span> <span class="special">&</span><span class="identifier">lhs</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">contains</span><span class="special"><</span><span class="identifier">T</span><span class="special">></span> <span class="special">&</span><span class="identifier">rhs</span><span class="special">)</span> <span class="special">{</span> + <span class="keyword">return</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">,</span> <span class="identifier">rhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">);</span> +<span class="special">}</span> + +<span class="keyword">class</span> <span class="identifier">bad</span> <span class="special">{</span> <span class="special">};</span> +<span class="keyword">class</span> <span class="identifier">good</span> <span class="special">{</span> <span class="special">};</span> +<span class="keyword">bool</span> <span class="identifier">f</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">good</span><span class="special">&,</span> <span class="keyword">const</span> <span class="identifier">good</span><span class="special">&)</span> <span class="special">{</span> <span class="special">}</span> + +<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span> <span class="special">{</span> + <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special"><<</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">boolalpha</span><span class="special">;</span> + <span class="comment">// works fine for contains<good></span> + <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special"><<</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_bit_and_assign</span><span class="special"><</span> <span class="identifier">contains</span><span class="special"><</span> <span class="identifier">good</span> <span class="special">></span> <span class="special">>::</span><span class="identifier">value</span><span class="special"><<</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true</span> + <span class="identifier">contains</span><span class="special"><</span><span class="identifier">good</span><span class="special">></span> <span class="identifier">g</span><span class="special">;</span> + <span class="identifier">g</span><span class="special">&=</span><span class="identifier">g</span><span class="special">;</span> <span class="comment">// ok</span> + <span class="comment">// does not work for contains<bad></span> + <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special"><<</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_bit_and_assign</span><span class="special"><</span> <span class="identifier">contains</span><span class="special"><</span> <span class="identifier">bad</span> <span class="special">></span> <span class="special">>::</span><span class="identifier">value</span><span class="special"><<</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true, should be false</span> + <span class="identifier">contains</span><span class="special"><</span><span class="identifier">bad</span><span class="special">></span> <span class="identifier">b</span><span class="special">;</span> + <span class="identifier">b</span><span class="special">&=</span><span class="identifier">b</span><span class="special">;</span> <span class="comment">// compile time error</span> + <span class="keyword">return</span> <span class="number">0</span><span class="special">;</span> +<span class="special">}</span> +</pre> + </li> +<li class="listitem"> + <code class="computeroutput"><span class="keyword">volatile</span></code> qualifier is not + properly handled and would lead to undefined behavior + </li> +</ul></div> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="has_bit_and.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="has_bit_or.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/reference/has_bit_or.html b/libs/type_traits/doc/html/boost_typetraits/reference/has_bit_or.html new file mode 100644 index 0000000000..ab9287ec15 --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/reference/has_bit_or.html @@ -0,0 +1,190 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>has_bit_or</title> +<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../reference.html" title="Alphabetical Reference"> +<link rel="prev" href="has_bit_and_assign.html" title="has_bit_and_assign"> +<link rel="next" href="has_bit_or_assign.html" title="has_bit_or_assign"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td> +<td align="center"><a href="../../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="has_bit_and_assign.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="has_bit_or_assign.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h3 class="title"> +<a name="boost_typetraits.reference.has_bit_or"></a><a class="link" href="has_bit_or.html" title="has_bit_or">has_bit_or</a> +</h3></div></div></div> +<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">Lhs</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Rhs</span><span class="special">=</span><span class="identifier">Lhs</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Ret</span><span class="special">=</span><span class="identifier">dont_care</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">has_bit_or</span> <span class="special">:</span> <span class="keyword">public</span> <em class="replaceable"><code><a class="link" href="integral_constant.html" title="integral_constant">true_type</a>-or-<a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code></em> <span class="special">{};</span> +</pre> +<p> + <span class="bold"><strong>Inherits:</strong></span> If (i) <code class="computeroutput"><span class="identifier">lhs</span></code> + of type <code class="computeroutput"><span class="identifier">Lhs</span></code> and <code class="computeroutput"><span class="identifier">rhs</span></code> of type <code class="computeroutput"><span class="identifier">Rhs</span></code> + can be used in expression <code class="computeroutput"><span class="identifier">lhs</span><span class="special">|</span><span class="identifier">rhs</span></code>, and + (ii) <code class="computeroutput"><span class="identifier">Ret</span><span class="special">=</span><span class="identifier">dont_care</span></code> or the result of expression + <code class="computeroutput"><span class="identifier">lhs</span><span class="special">|</span><span class="identifier">rhs</span></code> is convertible to <code class="computeroutput"><span class="identifier">Ret</span></code> + then inherits from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>, + otherwise inherits from <a class="link" href="integral_constant.html" title="integral_constant">false_type</a>. + </p> +<p> + The default behaviour (<code class="computeroutput"><span class="identifier">Ret</span><span class="special">=</span><span class="identifier">dont_care</span></code>) + is to not check for the return value of binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">|</span></code>. If <code class="computeroutput"><span class="identifier">Ret</span></code> + is different from the default <code class="computeroutput"><span class="identifier">dont_care</span></code> + type, the return value is checked to be convertible to <code class="computeroutput"><span class="identifier">Ret</span></code>. + Convertible to <code class="computeroutput"><span class="identifier">Ret</span></code> means + that the return value of the operator can be used as argument to a function + expecting <code class="computeroutput"><span class="identifier">Ret</span></code>: +</p> +<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">Ret</span><span class="special">);</span> +<span class="identifier">Lhs</span> <span class="identifier">lhs</span><span class="special">;</span> +<span class="identifier">Rhs</span> <span class="identifier">rhs</span><span class="special">;</span> +<span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">|</span><span class="identifier">rhs</span><span class="special">);</span> <span class="comment">// is valid if has_bit_or<Lhs, Rhs, Ret>::value==true</span> +</pre> +<p> + If <code class="computeroutput"><span class="identifier">Ret</span><span class="special">=</span><span class="keyword">void</span></code>, the return type is checked to be exactly + <code class="computeroutput"><span class="keyword">void</span></code>. + </p> +<p> + <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"><span class="preprocessor">#include</span> + <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_bit_or</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_operator</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + </p> +<p> + <span class="bold"><strong>Examples:</strong></span> + </p> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_bit_or</span><span class="special"><</span><span class="identifier">Lhs</span><span class="special">,</span> <span class="identifier">Rhs</span><span class="special">,</span> <span class="identifier">Ret</span><span class="special">>::</span><span class="identifier">value_type</span></code> is the type <code class="computeroutput"><span class="keyword">bool</span></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_bit_or</span><span class="special"><</span><span class="identifier">Lhs</span><span class="special">,</span> <span class="identifier">Rhs</span><span class="special">,</span> <span class="identifier">Ret</span><span class="special">>::</span><span class="identifier">value</span></code> is a <code class="computeroutput"><span class="keyword">bool</span></code> + integral constant expression. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_bit_or</span><span class="special"><</span><span class="keyword">int</span><span class="special">>::</span><span class="identifier">value</span></code> is a <code class="computeroutput"><span class="keyword">bool</span></code> + integral constant expression that evaluates to <code class="computeroutput"><span class="keyword">true</span></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_bit_or</span><span class="special"><</span><span class="keyword">long</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_bit_or</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_bit_or</span><span class="special"><</span><span class="keyword">const</span> <span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_bit_or</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">bool</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_bit_or</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>. + </p></blockquote></div> +<p> + <span class="bold"><strong>See also:</strong></span> <a class="link" href="../category/value_traits/operators.html" title="Operator Type Traits">Operator + Type Traits</a> + </p> +<p> + <span class="bold"><strong>Limitation:</strong></span> + </p> +<div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"> + Requires a compiler with working SFINAE. + </li></ul></div> +<p> + <span class="bold"><strong>Known issues:</strong></span> + </p> +<div class="itemizedlist"><ul class="itemizedlist" type="disc"> +<li class="listitem"> + This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">|</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">|</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">Lhs</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_bit_or</span><span class="special"><</span><span class="identifier">Lhs</span><span class="special">></span></code> + will produce a compiler error. For this reason <code class="computeroutput"><span class="identifier">has_bit_or</span></code> + cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">|</span></code> + or not. +<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">|(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&);</span> <span class="special">};</span> +<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_bit_or</span><span class="special"><</span><span class="identifier">A</span><span class="special">>::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator|(const A&) is private</span> +</pre> + </li> +<li class="listitem"> + There is an issue if the operator exists only for type <code class="computeroutput"><span class="identifier">A</span></code> and <code class="computeroutput"><span class="identifier">B</span></code> + is convertible to <code class="computeroutput"><span class="identifier">A</span></code>. + In this case, the compiler will report an ambiguous overload. +<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span> +<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">|(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&,</span> <span class="keyword">const</span> <span class="identifier">A</span><span class="special">&);</span> +<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span> +<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_bit_or</span><span class="special"><</span><span class="identifier">A</span><span class="special">>::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine</span> +<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_bit_or</span><span class="special"><</span><span class="identifier">B</span><span class="special">>::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambiguous overload</span> +</pre> + </li> +<li class="listitem"> + There is an issue when applying this trait to template classes. If <code class="computeroutput"><span class="keyword">operator</span><span class="special">|</span></code> + is defined but does not bind for a given template type, it is still detected + by the trait which returns <code class="computeroutput"><span class="keyword">true</span></code> + instead of <code class="computeroutput"><span class="keyword">false</span></code>. Example: + +<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_bit_or</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span> +<span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">iostream</span><span class="special">></span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">contains</span> <span class="special">{</span> <span class="identifier">T</span> <span class="identifier">data</span><span class="special">;</span> <span class="special">};</span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">|(</span><span class="keyword">const</span> <span class="identifier">contains</span><span class="special"><</span><span class="identifier">T</span><span class="special">></span> <span class="special">&</span><span class="identifier">lhs</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">contains</span><span class="special"><</span><span class="identifier">T</span><span class="special">></span> <span class="special">&</span><span class="identifier">rhs</span><span class="special">)</span> <span class="special">{</span> + <span class="keyword">return</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">,</span> <span class="identifier">rhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">);</span> +<span class="special">}</span> + +<span class="keyword">class</span> <span class="identifier">bad</span> <span class="special">{</span> <span class="special">};</span> +<span class="keyword">class</span> <span class="identifier">good</span> <span class="special">{</span> <span class="special">};</span> +<span class="keyword">bool</span> <span class="identifier">f</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">good</span><span class="special">&,</span> <span class="keyword">const</span> <span class="identifier">good</span><span class="special">&)</span> <span class="special">{</span> <span class="special">}</span> + +<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span> <span class="special">{</span> + <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special"><<</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">boolalpha</span><span class="special">;</span> + <span class="comment">// works fine for contains<good></span> + <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special"><<</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_bit_or</span><span class="special"><</span> <span class="identifier">contains</span><span class="special"><</span> <span class="identifier">good</span> <span class="special">></span> <span class="special">>::</span><span class="identifier">value</span><span class="special"><<</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true</span> + <span class="identifier">contains</span><span class="special"><</span><span class="identifier">good</span><span class="special">></span> <span class="identifier">g</span><span class="special">;</span> + <span class="identifier">g</span><span class="special">|</span><span class="identifier">g</span><span class="special">;</span> <span class="comment">// ok</span> + <span class="comment">// does not work for contains<bad></span> + <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special"><<</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_bit_or</span><span class="special"><</span> <span class="identifier">contains</span><span class="special"><</span> <span class="identifier">bad</span> <span class="special">></span> <span class="special">>::</span><span class="identifier">value</span><span class="special"><<</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true, should be false</span> + <span class="identifier">contains</span><span class="special"><</span><span class="identifier">bad</span><span class="special">></span> <span class="identifier">b</span><span class="special">;</span> + <span class="identifier">b</span><span class="special">|</span><span class="identifier">b</span><span class="special">;</span> <span class="comment">// compile time error</span> + <span class="keyword">return</span> <span class="number">0</span><span class="special">;</span> +<span class="special">}</span> +</pre> + </li> +<li class="listitem"> + <code class="computeroutput"><span class="keyword">volatile</span></code> qualifier is not + properly handled and would lead to undefined behavior + </li> +</ul></div> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="has_bit_and_assign.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="has_bit_or_assign.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/reference/has_bit_or_assign.html b/libs/type_traits/doc/html/boost_typetraits/reference/has_bit_or_assign.html new file mode 100644 index 0000000000..969ade9aec --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/reference/has_bit_or_assign.html @@ -0,0 +1,192 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>has_bit_or_assign</title> +<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../reference.html" title="Alphabetical Reference"> +<link rel="prev" href="has_bit_or.html" title="has_bit_or"> +<link rel="next" href="has_bit_xor.html" title="has_bit_xor"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td> +<td align="center"><a href="../../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="has_bit_or.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="has_bit_xor.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h3 class="title"> +<a name="boost_typetraits.reference.has_bit_or_assign"></a><a class="link" href="has_bit_or_assign.html" title="has_bit_or_assign">has_bit_or_assign</a> +</h3></div></div></div> +<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">Lhs</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Rhs</span><span class="special">=</span><span class="identifier">Lhs</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Ret</span><span class="special">=</span><span class="identifier">dont_care</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">has_bit_or_assign</span> <span class="special">:</span> <span class="keyword">public</span> <em class="replaceable"><code><a class="link" href="integral_constant.html" title="integral_constant">true_type</a>-or-<a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code></em> <span class="special">{};</span> +</pre> +<p> + <span class="bold"><strong>Inherits:</strong></span> If (i) <code class="computeroutput"><span class="identifier">lhs</span></code> + of type <code class="computeroutput"><span class="identifier">Lhs</span></code> and <code class="computeroutput"><span class="identifier">rhs</span></code> of type <code class="computeroutput"><span class="identifier">Rhs</span></code> + can be used in expression <code class="computeroutput"><span class="identifier">lhs</span><span class="special">|=</span><span class="identifier">rhs</span></code>, + and (ii) <code class="computeroutput"><span class="identifier">Ret</span><span class="special">=</span><span class="identifier">dont_care</span></code> or the result of expression + <code class="computeroutput"><span class="identifier">lhs</span><span class="special">|=</span><span class="identifier">rhs</span></code> is convertible to <code class="computeroutput"><span class="identifier">Ret</span></code> + then inherits from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>, + otherwise inherits from <a class="link" href="integral_constant.html" title="integral_constant">false_type</a>. + </p> +<p> + The default behaviour (<code class="computeroutput"><span class="identifier">Ret</span><span class="special">=</span><span class="identifier">dont_care</span></code>) + is to not check for the return value of binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">|=</span></code>. If <code class="computeroutput"><span class="identifier">Ret</span></code> + is different from the default <code class="computeroutput"><span class="identifier">dont_care</span></code> + type, the return value is checked to be convertible to <code class="computeroutput"><span class="identifier">Ret</span></code>. + Convertible to <code class="computeroutput"><span class="identifier">Ret</span></code> means + that the return value of the operator can be used as argument to a function + expecting <code class="computeroutput"><span class="identifier">Ret</span></code>: +</p> +<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">Ret</span><span class="special">);</span> +<span class="identifier">Lhs</span> <span class="identifier">lhs</span><span class="special">;</span> +<span class="identifier">Rhs</span> <span class="identifier">rhs</span><span class="special">;</span> +<span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">|=</span><span class="identifier">rhs</span><span class="special">);</span> <span class="comment">// is valid if has_bit_or_assign<Lhs, Rhs, Ret>::value==true</span> +</pre> +<p> + If <code class="computeroutput"><span class="identifier">Ret</span><span class="special">=</span><span class="keyword">void</span></code>, the return type is checked to be exactly + <code class="computeroutput"><span class="keyword">void</span></code>. + </p> +<p> + <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"><span class="preprocessor">#include</span> + <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_bit_or_assign</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_operator</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + </p> +<p> + <span class="bold"><strong>Examples:</strong></span> + </p> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_bit_or_assign</span><span class="special"><</span><span class="identifier">Lhs</span><span class="special">,</span> <span class="identifier">Rhs</span><span class="special">,</span> <span class="identifier">Ret</span><span class="special">>::</span><span class="identifier">value_type</span></code> is the type <code class="computeroutput"><span class="keyword">bool</span></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_bit_or_assign</span><span class="special"><</span><span class="identifier">Lhs</span><span class="special">,</span> <span class="identifier">Rhs</span><span class="special">,</span> <span class="identifier">Ret</span><span class="special">>::</span><span class="identifier">value</span></code> is a <code class="computeroutput"><span class="keyword">bool</span></code> + integral constant expression. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_bit_or_assign</span><span class="special"><</span><span class="keyword">int</span><span class="special">>::</span><span class="identifier">value</span></code> is a <code class="computeroutput"><span class="keyword">bool</span></code> + integral constant expression that evaluates to <code class="computeroutput"><span class="keyword">true</span></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_bit_or_assign</span><span class="special"><</span><span class="keyword">long</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_bit_or_assign</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_bit_or_assign</span><span class="special"><</span><span class="keyword">const</span> <span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_bit_or_assign</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">bool</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_bit_or_assign</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>. + </p></blockquote></div> +<p> + <span class="bold"><strong>See also:</strong></span> <a class="link" href="../category/value_traits/operators.html" title="Operator Type Traits">Operator + Type Traits</a> + </p> +<p> + <span class="bold"><strong>Limitation:</strong></span> + </p> +<div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"> + Requires a compiler with working SFINAE. + </li></ul></div> +<p> + <span class="bold"><strong>Known issues:</strong></span> + </p> +<div class="itemizedlist"><ul class="itemizedlist" type="disc"> +<li class="listitem"> + This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">|=</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">|=</span></code> + is defined as a private member of <code class="computeroutput"><span class="identifier">Lhs</span></code> + then instantiating <code class="computeroutput"><span class="identifier">has_bit_or_assign</span><span class="special"><</span><span class="identifier">Lhs</span><span class="special">></span></code> will produce a compiler error. For + this reason <code class="computeroutput"><span class="identifier">has_bit_or_assign</span></code> + cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">|=</span></code> + or not. +<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">|=(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&);</span> <span class="special">};</span> +<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_bit_or_assign</span><span class="special"><</span><span class="identifier">A</span><span class="special">>::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator|=(const A&) is private</span> +</pre> + </li> +<li class="listitem"> + There is an issue if the operator exists only for type <code class="computeroutput"><span class="identifier">A</span></code> and <code class="computeroutput"><span class="identifier">B</span></code> + is convertible to <code class="computeroutput"><span class="identifier">A</span></code>. + In this case, the compiler will report an ambiguous overload. +<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span> +<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">|=(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&,</span> <span class="keyword">const</span> <span class="identifier">A</span><span class="special">&);</span> +<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span> +<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_bit_or_assign</span><span class="special"><</span><span class="identifier">A</span><span class="special">>::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine</span> +<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_bit_or_assign</span><span class="special"><</span><span class="identifier">B</span><span class="special">>::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambiguous overload</span> +</pre> + </li> +<li class="listitem"> + There is an issue when applying this trait to template classes. If <code class="computeroutput"><span class="keyword">operator</span><span class="special">|=</span></code> + is defined but does not bind for a given template type, it is still detected + by the trait which returns <code class="computeroutput"><span class="keyword">true</span></code> + instead of <code class="computeroutput"><span class="keyword">false</span></code>. Example: + +<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_bit_or_assign</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span> +<span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">iostream</span><span class="special">></span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">contains</span> <span class="special">{</span> <span class="identifier">T</span> <span class="identifier">data</span><span class="special">;</span> <span class="special">};</span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">|=(</span><span class="keyword">const</span> <span class="identifier">contains</span><span class="special"><</span><span class="identifier">T</span><span class="special">></span> <span class="special">&</span><span class="identifier">lhs</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">contains</span><span class="special"><</span><span class="identifier">T</span><span class="special">></span> <span class="special">&</span><span class="identifier">rhs</span><span class="special">)</span> <span class="special">{</span> + <span class="keyword">return</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">,</span> <span class="identifier">rhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">);</span> +<span class="special">}</span> + +<span class="keyword">class</span> <span class="identifier">bad</span> <span class="special">{</span> <span class="special">};</span> +<span class="keyword">class</span> <span class="identifier">good</span> <span class="special">{</span> <span class="special">};</span> +<span class="keyword">bool</span> <span class="identifier">f</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">good</span><span class="special">&,</span> <span class="keyword">const</span> <span class="identifier">good</span><span class="special">&)</span> <span class="special">{</span> <span class="special">}</span> + +<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span> <span class="special">{</span> + <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special"><<</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">boolalpha</span><span class="special">;</span> + <span class="comment">// works fine for contains<good></span> + <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special"><<</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_bit_or_assign</span><span class="special"><</span> <span class="identifier">contains</span><span class="special"><</span> <span class="identifier">good</span> <span class="special">></span> <span class="special">>::</span><span class="identifier">value</span><span class="special"><<</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true</span> + <span class="identifier">contains</span><span class="special"><</span><span class="identifier">good</span><span class="special">></span> <span class="identifier">g</span><span class="special">;</span> + <span class="identifier">g</span><span class="special">|=</span><span class="identifier">g</span><span class="special">;</span> <span class="comment">// ok</span> + <span class="comment">// does not work for contains<bad></span> + <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special"><<</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_bit_or_assign</span><span class="special"><</span> <span class="identifier">contains</span><span class="special"><</span> <span class="identifier">bad</span> <span class="special">></span> <span class="special">>::</span><span class="identifier">value</span><span class="special"><<</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true, should be false</span> + <span class="identifier">contains</span><span class="special"><</span><span class="identifier">bad</span><span class="special">></span> <span class="identifier">b</span><span class="special">;</span> + <span class="identifier">b</span><span class="special">|=</span><span class="identifier">b</span><span class="special">;</span> <span class="comment">// compile time error</span> + <span class="keyword">return</span> <span class="number">0</span><span class="special">;</span> +<span class="special">}</span> +</pre> + </li> +<li class="listitem"> + <code class="computeroutput"><span class="keyword">volatile</span></code> qualifier is not + properly handled and would lead to undefined behavior + </li> +</ul></div> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="has_bit_or.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="has_bit_xor.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/reference/has_bit_xor.html b/libs/type_traits/doc/html/boost_typetraits/reference/has_bit_xor.html new file mode 100644 index 0000000000..d1a282dd8c --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/reference/has_bit_xor.html @@ -0,0 +1,190 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>has_bit_xor</title> +<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../reference.html" title="Alphabetical Reference"> +<link rel="prev" href="has_bit_or_assign.html" title="has_bit_or_assign"> +<link rel="next" href="has_bit_xor_assign.html" title="has_bit_xor_assign"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td> +<td align="center"><a href="../../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="has_bit_or_assign.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="has_bit_xor_assign.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h3 class="title"> +<a name="boost_typetraits.reference.has_bit_xor"></a><a class="link" href="has_bit_xor.html" title="has_bit_xor">has_bit_xor</a> +</h3></div></div></div> +<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">Lhs</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Rhs</span><span class="special">=</span><span class="identifier">Lhs</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Ret</span><span class="special">=</span><span class="identifier">dont_care</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">has_bit_xor</span> <span class="special">:</span> <span class="keyword">public</span> <em class="replaceable"><code><a class="link" href="integral_constant.html" title="integral_constant">true_type</a>-or-<a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code></em> <span class="special">{};</span> +</pre> +<p> + <span class="bold"><strong>Inherits:</strong></span> If (i) <code class="computeroutput"><span class="identifier">lhs</span></code> + of type <code class="computeroutput"><span class="identifier">Lhs</span></code> and <code class="computeroutput"><span class="identifier">rhs</span></code> of type <code class="computeroutput"><span class="identifier">Rhs</span></code> + can be used in expression <code class="computeroutput"><span class="identifier">lhs</span><span class="special">^</span><span class="identifier">rhs</span></code>, and + (ii) <code class="computeroutput"><span class="identifier">Ret</span><span class="special">=</span><span class="identifier">dont_care</span></code> or the result of expression + <code class="computeroutput"><span class="identifier">lhs</span><span class="special">^</span><span class="identifier">rhs</span></code> is convertible to <code class="computeroutput"><span class="identifier">Ret</span></code> + then inherits from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>, + otherwise inherits from <a class="link" href="integral_constant.html" title="integral_constant">false_type</a>. + </p> +<p> + The default behaviour (<code class="computeroutput"><span class="identifier">Ret</span><span class="special">=</span><span class="identifier">dont_care</span></code>) + is to not check for the return value of binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">^</span></code>. If <code class="computeroutput"><span class="identifier">Ret</span></code> + is different from the default <code class="computeroutput"><span class="identifier">dont_care</span></code> + type, the return value is checked to be convertible to <code class="computeroutput"><span class="identifier">Ret</span></code>. + Convertible to <code class="computeroutput"><span class="identifier">Ret</span></code> means + that the return value of the operator can be used as argument to a function + expecting <code class="computeroutput"><span class="identifier">Ret</span></code>: +</p> +<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">Ret</span><span class="special">);</span> +<span class="identifier">Lhs</span> <span class="identifier">lhs</span><span class="special">;</span> +<span class="identifier">Rhs</span> <span class="identifier">rhs</span><span class="special">;</span> +<span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">^</span><span class="identifier">rhs</span><span class="special">);</span> <span class="comment">// is valid if has_bit_xor<Lhs, Rhs, Ret>::value==true</span> +</pre> +<p> + If <code class="computeroutput"><span class="identifier">Ret</span><span class="special">=</span><span class="keyword">void</span></code>, the return type is checked to be exactly + <code class="computeroutput"><span class="keyword">void</span></code>. + </p> +<p> + <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"><span class="preprocessor">#include</span> + <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_bit_xor</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_operator</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + </p> +<p> + <span class="bold"><strong>Examples:</strong></span> + </p> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_bit_xor</span><span class="special"><</span><span class="identifier">Lhs</span><span class="special">,</span> <span class="identifier">Rhs</span><span class="special">,</span> <span class="identifier">Ret</span><span class="special">>::</span><span class="identifier">value_type</span></code> is the type <code class="computeroutput"><span class="keyword">bool</span></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_bit_xor</span><span class="special"><</span><span class="identifier">Lhs</span><span class="special">,</span> <span class="identifier">Rhs</span><span class="special">,</span> <span class="identifier">Ret</span><span class="special">>::</span><span class="identifier">value</span></code> is a <code class="computeroutput"><span class="keyword">bool</span></code> + integral constant expression. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_bit_xor</span><span class="special"><</span><span class="keyword">int</span><span class="special">>::</span><span class="identifier">value</span></code> is a <code class="computeroutput"><span class="keyword">bool</span></code> + integral constant expression that evaluates to <code class="computeroutput"><span class="keyword">true</span></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_bit_xor</span><span class="special"><</span><span class="keyword">long</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_bit_xor</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_bit_xor</span><span class="special"><</span><span class="keyword">const</span> <span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_bit_xor</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">bool</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_bit_xor</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>. + </p></blockquote></div> +<p> + <span class="bold"><strong>See also:</strong></span> <a class="link" href="../category/value_traits/operators.html" title="Operator Type Traits">Operator + Type Traits</a> + </p> +<p> + <span class="bold"><strong>Limitation:</strong></span> + </p> +<div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"> + Requires a compiler with working SFINAE. + </li></ul></div> +<p> + <span class="bold"><strong>Known issues:</strong></span> + </p> +<div class="itemizedlist"><ul class="itemizedlist" type="disc"> +<li class="listitem"> + This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">^</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">^</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">Lhs</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_bit_xor</span><span class="special"><</span><span class="identifier">Lhs</span><span class="special">></span></code> + will produce a compiler error. For this reason <code class="computeroutput"><span class="identifier">has_bit_xor</span></code> + cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">^</span></code> + or not. +<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">^(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&);</span> <span class="special">};</span> +<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_bit_xor</span><span class="special"><</span><span class="identifier">A</span><span class="special">>::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator^(const A&) is private</span> +</pre> + </li> +<li class="listitem"> + There is an issue if the operator exists only for type <code class="computeroutput"><span class="identifier">A</span></code> and <code class="computeroutput"><span class="identifier">B</span></code> + is convertible to <code class="computeroutput"><span class="identifier">A</span></code>. + In this case, the compiler will report an ambiguous overload. +<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span> +<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">^(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&,</span> <span class="keyword">const</span> <span class="identifier">A</span><span class="special">&);</span> +<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span> +<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_bit_xor</span><span class="special"><</span><span class="identifier">A</span><span class="special">>::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine</span> +<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_bit_xor</span><span class="special"><</span><span class="identifier">B</span><span class="special">>::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambiguous overload</span> +</pre> + </li> +<li class="listitem"> + There is an issue when applying this trait to template classes. If <code class="computeroutput"><span class="keyword">operator</span><span class="special">^</span></code> + is defined but does not bind for a given template type, it is still detected + by the trait which returns <code class="computeroutput"><span class="keyword">true</span></code> + instead of <code class="computeroutput"><span class="keyword">false</span></code>. Example: + +<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_bit_xor</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span> +<span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">iostream</span><span class="special">></span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">contains</span> <span class="special">{</span> <span class="identifier">T</span> <span class="identifier">data</span><span class="special">;</span> <span class="special">};</span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">^(</span><span class="keyword">const</span> <span class="identifier">contains</span><span class="special"><</span><span class="identifier">T</span><span class="special">></span> <span class="special">&</span><span class="identifier">lhs</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">contains</span><span class="special"><</span><span class="identifier">T</span><span class="special">></span> <span class="special">&</span><span class="identifier">rhs</span><span class="special">)</span> <span class="special">{</span> + <span class="keyword">return</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">,</span> <span class="identifier">rhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">);</span> +<span class="special">}</span> + +<span class="keyword">class</span> <span class="identifier">bad</span> <span class="special">{</span> <span class="special">};</span> +<span class="keyword">class</span> <span class="identifier">good</span> <span class="special">{</span> <span class="special">};</span> +<span class="keyword">bool</span> <span class="identifier">f</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">good</span><span class="special">&,</span> <span class="keyword">const</span> <span class="identifier">good</span><span class="special">&)</span> <span class="special">{</span> <span class="special">}</span> + +<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span> <span class="special">{</span> + <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special"><<</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">boolalpha</span><span class="special">;</span> + <span class="comment">// works fine for contains<good></span> + <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special"><<</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_bit_xor</span><span class="special"><</span> <span class="identifier">contains</span><span class="special"><</span> <span class="identifier">good</span> <span class="special">></span> <span class="special">>::</span><span class="identifier">value</span><span class="special"><<</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true</span> + <span class="identifier">contains</span><span class="special"><</span><span class="identifier">good</span><span class="special">></span> <span class="identifier">g</span><span class="special">;</span> + <span class="identifier">g</span><span class="special">^</span><span class="identifier">g</span><span class="special">;</span> <span class="comment">// ok</span> + <span class="comment">// does not work for contains<bad></span> + <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special"><<</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_bit_xor</span><span class="special"><</span> <span class="identifier">contains</span><span class="special"><</span> <span class="identifier">bad</span> <span class="special">></span> <span class="special">>::</span><span class="identifier">value</span><span class="special"><<</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true, should be false</span> + <span class="identifier">contains</span><span class="special"><</span><span class="identifier">bad</span><span class="special">></span> <span class="identifier">b</span><span class="special">;</span> + <span class="identifier">b</span><span class="special">^</span><span class="identifier">b</span><span class="special">;</span> <span class="comment">// compile time error</span> + <span class="keyword">return</span> <span class="number">0</span><span class="special">;</span> +<span class="special">}</span> +</pre> + </li> +<li class="listitem"> + <code class="computeroutput"><span class="keyword">volatile</span></code> qualifier is not + properly handled and would lead to undefined behavior + </li> +</ul></div> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="has_bit_or_assign.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="has_bit_xor_assign.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/reference/has_bit_xor_assign.html b/libs/type_traits/doc/html/boost_typetraits/reference/has_bit_xor_assign.html new file mode 100644 index 0000000000..341274a2e8 --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/reference/has_bit_xor_assign.html @@ -0,0 +1,192 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>has_bit_xor_assign</title> +<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../reference.html" title="Alphabetical Reference"> +<link rel="prev" href="has_bit_xor.html" title="has_bit_xor"> +<link rel="next" href="has_complement.html" title="has_complement"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td> +<td align="center"><a href="../../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="has_bit_xor.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="has_complement.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h3 class="title"> +<a name="boost_typetraits.reference.has_bit_xor_assign"></a><a class="link" href="has_bit_xor_assign.html" title="has_bit_xor_assign">has_bit_xor_assign</a> +</h3></div></div></div> +<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">Lhs</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Rhs</span><span class="special">=</span><span class="identifier">Lhs</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Ret</span><span class="special">=</span><span class="identifier">dont_care</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">has_bit_xor_assign</span> <span class="special">:</span> <span class="keyword">public</span> <em class="replaceable"><code><a class="link" href="integral_constant.html" title="integral_constant">true_type</a>-or-<a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code></em> <span class="special">{};</span> +</pre> +<p> + <span class="bold"><strong>Inherits:</strong></span> If (i) <code class="computeroutput"><span class="identifier">lhs</span></code> + of type <code class="computeroutput"><span class="identifier">Lhs</span></code> and <code class="computeroutput"><span class="identifier">rhs</span></code> of type <code class="computeroutput"><span class="identifier">Rhs</span></code> + can be used in expression <code class="computeroutput"><span class="identifier">lhs</span><span class="special">^=</span><span class="identifier">rhs</span></code>, + and (ii) <code class="computeroutput"><span class="identifier">Ret</span><span class="special">=</span><span class="identifier">dont_care</span></code> or the result of expression + <code class="computeroutput"><span class="identifier">lhs</span><span class="special">^=</span><span class="identifier">rhs</span></code> is convertible to <code class="computeroutput"><span class="identifier">Ret</span></code> + then inherits from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>, + otherwise inherits from <a class="link" href="integral_constant.html" title="integral_constant">false_type</a>. + </p> +<p> + The default behaviour (<code class="computeroutput"><span class="identifier">Ret</span><span class="special">=</span><span class="identifier">dont_care</span></code>) + is to not check for the return value of binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">^=</span></code>. If <code class="computeroutput"><span class="identifier">Ret</span></code> + is different from the default <code class="computeroutput"><span class="identifier">dont_care</span></code> + type, the return value is checked to be convertible to <code class="computeroutput"><span class="identifier">Ret</span></code>. + Convertible to <code class="computeroutput"><span class="identifier">Ret</span></code> means + that the return value of the operator can be used as argument to a function + expecting <code class="computeroutput"><span class="identifier">Ret</span></code>: +</p> +<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">Ret</span><span class="special">);</span> +<span class="identifier">Lhs</span> <span class="identifier">lhs</span><span class="special">;</span> +<span class="identifier">Rhs</span> <span class="identifier">rhs</span><span class="special">;</span> +<span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">^=</span><span class="identifier">rhs</span><span class="special">);</span> <span class="comment">// is valid if has_bit_xor_assign<Lhs, Rhs, Ret>::value==true</span> +</pre> +<p> + If <code class="computeroutput"><span class="identifier">Ret</span><span class="special">=</span><span class="keyword">void</span></code>, the return type is checked to be exactly + <code class="computeroutput"><span class="keyword">void</span></code>. + </p> +<p> + <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"><span class="preprocessor">#include</span> + <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_bit_xor_assign</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_operator</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + </p> +<p> + <span class="bold"><strong>Examples:</strong></span> + </p> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_bit_xor_assign</span><span class="special"><</span><span class="identifier">Lhs</span><span class="special">,</span> <span class="identifier">Rhs</span><span class="special">,</span> <span class="identifier">Ret</span><span class="special">>::</span><span class="identifier">value_type</span></code> is the type <code class="computeroutput"><span class="keyword">bool</span></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_bit_xor_assign</span><span class="special"><</span><span class="identifier">Lhs</span><span class="special">,</span> <span class="identifier">Rhs</span><span class="special">,</span> <span class="identifier">Ret</span><span class="special">>::</span><span class="identifier">value</span></code> is a <code class="computeroutput"><span class="keyword">bool</span></code> + integral constant expression. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_bit_xor_assign</span><span class="special"><</span><span class="keyword">int</span><span class="special">>::</span><span class="identifier">value</span></code> is a <code class="computeroutput"><span class="keyword">bool</span></code> + integral constant expression that evaluates to <code class="computeroutput"><span class="keyword">true</span></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_bit_xor_assign</span><span class="special"><</span><span class="keyword">long</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_bit_xor_assign</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_bit_xor_assign</span><span class="special"><</span><span class="keyword">const</span> <span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_bit_xor_assign</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">bool</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_bit_xor_assign</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>. + </p></blockquote></div> +<p> + <span class="bold"><strong>See also:</strong></span> <a class="link" href="../category/value_traits/operators.html" title="Operator Type Traits">Operator + Type Traits</a> + </p> +<p> + <span class="bold"><strong>Limitation:</strong></span> + </p> +<div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"> + Requires a compiler with working SFINAE. + </li></ul></div> +<p> + <span class="bold"><strong>Known issues:</strong></span> + </p> +<div class="itemizedlist"><ul class="itemizedlist" type="disc"> +<li class="listitem"> + This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">^=</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">^=</span></code> + is defined as a private member of <code class="computeroutput"><span class="identifier">Lhs</span></code> + then instantiating <code class="computeroutput"><span class="identifier">has_bit_xor_assign</span><span class="special"><</span><span class="identifier">Lhs</span><span class="special">></span></code> will produce a compiler error. For + this reason <code class="computeroutput"><span class="identifier">has_bit_xor_assign</span></code> + cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">^=</span></code> + or not. +<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">^=(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&);</span> <span class="special">};</span> +<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_bit_xor_assign</span><span class="special"><</span><span class="identifier">A</span><span class="special">>::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator^=(const A&) is private</span> +</pre> + </li> +<li class="listitem"> + There is an issue if the operator exists only for type <code class="computeroutput"><span class="identifier">A</span></code> and <code class="computeroutput"><span class="identifier">B</span></code> + is convertible to <code class="computeroutput"><span class="identifier">A</span></code>. + In this case, the compiler will report an ambiguous overload. +<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span> +<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">^=(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&,</span> <span class="keyword">const</span> <span class="identifier">A</span><span class="special">&);</span> +<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span> +<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_bit_xor_assign</span><span class="special"><</span><span class="identifier">A</span><span class="special">>::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine</span> +<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_bit_xor_assign</span><span class="special"><</span><span class="identifier">B</span><span class="special">>::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambiguous overload</span> +</pre> + </li> +<li class="listitem"> + There is an issue when applying this trait to template classes. If <code class="computeroutput"><span class="keyword">operator</span><span class="special">^=</span></code> + is defined but does not bind for a given template type, it is still detected + by the trait which returns <code class="computeroutput"><span class="keyword">true</span></code> + instead of <code class="computeroutput"><span class="keyword">false</span></code>. Example: + +<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_bit_xor_assign</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span> +<span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">iostream</span><span class="special">></span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">contains</span> <span class="special">{</span> <span class="identifier">T</span> <span class="identifier">data</span><span class="special">;</span> <span class="special">};</span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">^=(</span><span class="keyword">const</span> <span class="identifier">contains</span><span class="special"><</span><span class="identifier">T</span><span class="special">></span> <span class="special">&</span><span class="identifier">lhs</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">contains</span><span class="special"><</span><span class="identifier">T</span><span class="special">></span> <span class="special">&</span><span class="identifier">rhs</span><span class="special">)</span> <span class="special">{</span> + <span class="keyword">return</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">,</span> <span class="identifier">rhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">);</span> +<span class="special">}</span> + +<span class="keyword">class</span> <span class="identifier">bad</span> <span class="special">{</span> <span class="special">};</span> +<span class="keyword">class</span> <span class="identifier">good</span> <span class="special">{</span> <span class="special">};</span> +<span class="keyword">bool</span> <span class="identifier">f</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">good</span><span class="special">&,</span> <span class="keyword">const</span> <span class="identifier">good</span><span class="special">&)</span> <span class="special">{</span> <span class="special">}</span> + +<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span> <span class="special">{</span> + <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special"><<</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">boolalpha</span><span class="special">;</span> + <span class="comment">// works fine for contains<good></span> + <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special"><<</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_bit_xor_assign</span><span class="special"><</span> <span class="identifier">contains</span><span class="special"><</span> <span class="identifier">good</span> <span class="special">></span> <span class="special">>::</span><span class="identifier">value</span><span class="special"><<</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true</span> + <span class="identifier">contains</span><span class="special"><</span><span class="identifier">good</span><span class="special">></span> <span class="identifier">g</span><span class="special">;</span> + <span class="identifier">g</span><span class="special">^=</span><span class="identifier">g</span><span class="special">;</span> <span class="comment">// ok</span> + <span class="comment">// does not work for contains<bad></span> + <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special"><<</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_bit_xor_assign</span><span class="special"><</span> <span class="identifier">contains</span><span class="special"><</span> <span class="identifier">bad</span> <span class="special">></span> <span class="special">>::</span><span class="identifier">value</span><span class="special"><<</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true, should be false</span> + <span class="identifier">contains</span><span class="special"><</span><span class="identifier">bad</span><span class="special">></span> <span class="identifier">b</span><span class="special">;</span> + <span class="identifier">b</span><span class="special">^=</span><span class="identifier">b</span><span class="special">;</span> <span class="comment">// compile time error</span> + <span class="keyword">return</span> <span class="number">0</span><span class="special">;</span> +<span class="special">}</span> +</pre> + </li> +<li class="listitem"> + <code class="computeroutput"><span class="keyword">volatile</span></code> qualifier is not + properly handled and would lead to undefined behavior + </li> +</ul></div> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="has_bit_xor.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="has_complement.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/reference/has_complement.html b/libs/type_traits/doc/html/boost_typetraits/reference/has_complement.html new file mode 100644 index 0000000000..20ed5b08f8 --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/reference/has_complement.html @@ -0,0 +1,199 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>has_complement</title> +<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../reference.html" title="Alphabetical Reference"> +<link rel="prev" href="has_bit_xor_assign.html" title="has_bit_xor_assign"> +<link rel="next" href="has_dereference.html" title="has_dereference"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td> +<td align="center"><a href="../../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="has_bit_xor_assign.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="has_dereference.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h3 class="title"> +<a name="boost_typetraits.reference.has_complement"></a><a class="link" href="has_complement.html" title="has_complement">has_complement</a> +</h3></div></div></div> +<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">Rhs</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Ret</span><span class="special">=</span><span class="identifier">dont_care</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">has_complement</span> <span class="special">:</span> <span class="keyword">public</span> <em class="replaceable"><code><a class="link" href="integral_constant.html" title="integral_constant">true_type</a>-or-<a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code></em> <span class="special">{};</span> +</pre> +<p> + <span class="bold"><strong>Inherits:</strong></span> If (i) <code class="computeroutput"><span class="identifier">rhs</span></code> + of type <code class="computeroutput"><span class="identifier">Rhs</span></code> can be used in + expression <code class="computeroutput"><span class="special">~</span><span class="identifier">rhs</span></code>, + and (ii) <code class="computeroutput"><span class="identifier">Ret</span><span class="special">=</span><span class="identifier">dont_care</span></code> or the result of expression + <code class="computeroutput"><span class="special">~</span><span class="identifier">rhs</span></code> + is convertible to <code class="computeroutput"><span class="identifier">Ret</span></code> then + inherits from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>, + otherwise inherits from <a class="link" href="integral_constant.html" title="integral_constant">false_type</a>. + </p> +<p> + The default behaviour (<code class="computeroutput"><span class="identifier">Ret</span><span class="special">=</span><span class="identifier">dont_care</span></code>) + is to not check for the return value of prefix <code class="computeroutput"><span class="keyword">operator</span><span class="special">~</span></code>. If <code class="computeroutput"><span class="identifier">Ret</span></code> + is different from the default <code class="computeroutput"><span class="identifier">dont_care</span></code> + type, the return value is checked to be convertible to <code class="computeroutput"><span class="identifier">Ret</span></code>. + Convertible to <code class="computeroutput"><span class="identifier">Ret</span></code> means + that the return value of the operator can be used as argument to a function + expecting <code class="computeroutput"><span class="identifier">Ret</span></code>: +</p> +<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">Ret</span><span class="special">);</span> +<span class="identifier">Rhs</span> <span class="identifier">rhs</span><span class="special">;</span> +<span class="identifier">f</span><span class="special">(~</span><span class="identifier">rhs</span><span class="special">);</span> <span class="comment">// is valid if has_complement<Rhs, Ret>::value==true</span> +</pre> +<p> + If <code class="computeroutput"><span class="identifier">Ret</span><span class="special">=</span><span class="keyword">void</span></code>, the return type is checked to be exactly + <code class="computeroutput"><span class="keyword">void</span></code>. + </p> +<p> + <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"><span class="preprocessor">#include</span> + <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_complement</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_operator</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + </p> +<p> + <span class="bold"><strong>Examples:</strong></span> + </p> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_complement</span><span class="special"><</span><span class="identifier">Rhs</span><span class="special">,</span> <span class="identifier">Ret</span><span class="special">>::</span><span class="identifier">value_type</span></code> is the type <code class="computeroutput"><span class="keyword">bool</span></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_complement</span><span class="special"><</span><span class="identifier">Rhs</span><span class="special">,</span> <span class="identifier">Ret</span><span class="special">>::</span><span class="identifier">value</span></code> is a <code class="computeroutput"><span class="keyword">bool</span></code> + integral constant expression. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_complement</span><span class="special"><</span><span class="keyword">int</span><span class="special">>::</span><span class="identifier">value</span></code> is a <code class="computeroutput"><span class="keyword">bool</span></code> + integral constant expression that evaluates to <code class="computeroutput"><span class="keyword">true</span></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_complement</span><span class="special"><</span><span class="keyword">long</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_complement</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_complement</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">long</span><span class="special">></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_complement</span><span class="special"><</span><span class="keyword">const</span> <span class="keyword">int</span><span class="special">></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_complement</span><span class="special"><</span><span class="keyword">int</span><span class="special">*></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_complement</span><span class="special"><</span><span class="keyword">double</span><span class="special">,</span> <span class="keyword">double</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_complement</span><span class="special"><</span><span class="keyword">double</span><span class="special">,</span> <span class="keyword">int</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_complement</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>. + </p></blockquote></div> +<p> + <span class="bold"><strong>See also:</strong></span> <a class="link" href="../category/value_traits/operators.html" title="Operator Type Traits">Operator + Type Traits</a> + </p> +<p> + <span class="bold"><strong>Limitation:</strong></span> + </p> +<div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"> + Requires a compiler with working SFINAE. + </li></ul></div> +<p> + <span class="bold"><strong>Known issues:</strong></span> + </p> +<div class="itemizedlist"><ul class="itemizedlist" type="disc"> +<li class="listitem"> + This trait cannot detect whether prefix <code class="computeroutput"><span class="keyword">operator</span><span class="special">~</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">~</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">Rhs</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_complement</span><span class="special"><</span><span class="identifier">Rhs</span><span class="special">></span></code> + will produce a compiler error. For this reason <code class="computeroutput"><span class="identifier">has_complement</span></code> + cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">~</span></code> + or not. +<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">~();</span> <span class="special">};</span> +<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_complement</span><span class="special"><</span><span class="identifier">A</span><span class="special">>::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator~() is private</span> +</pre> + </li> +<li class="listitem"> + There is an issue if the operator exists only for type <code class="computeroutput"><span class="identifier">A</span></code> and <code class="computeroutput"><span class="identifier">B</span></code> + is convertible to <code class="computeroutput"><span class="identifier">A</span></code>. + In this case, the compiler will report an ambiguous overload. +<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span> +<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">~(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&);</span> +<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span> +<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_complement</span><span class="special"><</span><span class="identifier">A</span><span class="special">>::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine</span> +<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_complement</span><span class="special"><</span><span class="identifier">B</span><span class="special">>::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambiguous overload</span> +</pre> + </li> +<li class="listitem"> + There is an issue when applying this trait to template classes. If <code class="computeroutput"><span class="keyword">operator</span><span class="special">~</span></code> + is defined but does not bind for a given template type, it is still detected + by the trait which returns <code class="computeroutput"><span class="keyword">true</span></code> + instead of <code class="computeroutput"><span class="keyword">false</span></code>. Example: + +<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_complement</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span> +<span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">iostream</span><span class="special">></span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">contains</span> <span class="special">{</span> <span class="identifier">T</span> <span class="identifier">data</span><span class="special">;</span> <span class="special">};</span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">~(</span><span class="keyword">const</span> <span class="identifier">contains</span><span class="special"><</span><span class="identifier">T</span><span class="special">></span> <span class="special">&</span><span class="identifier">rhs</span><span class="special">)</span> <span class="special">{</span> + <span class="keyword">return</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">rhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">);</span> +<span class="special">}</span> + +<span class="keyword">class</span> <span class="identifier">bad</span> <span class="special">{</span> <span class="special">};</span> +<span class="keyword">class</span> <span class="identifier">good</span> <span class="special">{</span> <span class="special">};</span> +<span class="keyword">bool</span> <span class="identifier">f</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">good</span><span class="special">&)</span> <span class="special">{</span> <span class="special">}</span> + +<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span> <span class="special">{</span> + <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special"><<</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">boolalpha</span><span class="special">;</span> + <span class="comment">// works fine for contains<good></span> + <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special"><<</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_complement</span><span class="special"><</span> <span class="identifier">contains</span><span class="special"><</span> <span class="identifier">good</span> <span class="special">></span> <span class="special">>::</span><span class="identifier">value</span><span class="special"><<</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true</span> + <span class="identifier">contains</span><span class="special"><</span><span class="identifier">good</span><span class="special">></span> <span class="identifier">g</span><span class="special">;</span> + <span class="special">~</span><span class="identifier">g</span><span class="special">;</span> <span class="comment">// ok</span> + <span class="comment">// does not work for contains<bad></span> + <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special"><<</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_complement</span><span class="special"><</span> <span class="identifier">contains</span><span class="special"><</span> <span class="identifier">bad</span> <span class="special">></span> <span class="special">>::</span><span class="identifier">value</span><span class="special"><<</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true, should be false</span> + <span class="identifier">contains</span><span class="special"><</span><span class="identifier">bad</span><span class="special">></span> <span class="identifier">b</span><span class="special">;</span> + <span class="special">~</span><span class="identifier">b</span><span class="special">;</span> <span class="comment">// compile time error</span> + <span class="keyword">return</span> <span class="number">0</span><span class="special">;</span> +<span class="special">}</span> +</pre> + </li> +<li class="listitem"> + <code class="computeroutput"><span class="keyword">volatile</span></code> qualifier is not + properly handled and would lead to undefined behavior + </li> +</ul></div> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="has_bit_xor_assign.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="has_dereference.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/reference/has_dereference.html b/libs/type_traits/doc/html/boost_typetraits/reference/has_dereference.html new file mode 100644 index 0000000000..2e6e4b18ed --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/reference/has_dereference.html @@ -0,0 +1,208 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>has_dereference</title> +<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../reference.html" title="Alphabetical Reference"> +<link rel="prev" href="has_complement.html" title="has_complement"> +<link rel="next" href="has_divides.html" title="has_divides"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td> +<td align="center"><a href="../../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="has_complement.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="has_divides.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h3 class="title"> +<a name="boost_typetraits.reference.has_dereference"></a><a class="link" href="has_dereference.html" title="has_dereference">has_dereference</a> +</h3></div></div></div> +<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">Rhs</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Ret</span><span class="special">=</span><span class="identifier">dont_care</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">has_dereference</span> <span class="special">:</span> <span class="keyword">public</span> <em class="replaceable"><code><a class="link" href="integral_constant.html" title="integral_constant">true_type</a>-or-<a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code></em> <span class="special">{};</span> +</pre> +<p> + <span class="bold"><strong>Inherits:</strong></span> If (i) <code class="computeroutput"><span class="identifier">rhs</span></code> + of type <code class="computeroutput"><span class="identifier">Rhs</span></code> can be used in + expression <code class="computeroutput"><span class="special">*</span><span class="identifier">rhs</span></code>, + and (ii) <code class="computeroutput"><span class="identifier">Ret</span><span class="special">=</span><span class="identifier">dont_care</span></code> or the result of expression + <code class="computeroutput"><span class="special">*</span><span class="identifier">rhs</span></code> + is convertible to <code class="computeroutput"><span class="identifier">Ret</span></code> then + inherits from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>, + otherwise inherits from <a class="link" href="integral_constant.html" title="integral_constant">false_type</a>. + </p> +<p> + The default behaviour (<code class="computeroutput"><span class="identifier">Ret</span><span class="special">=</span><span class="identifier">dont_care</span></code>) + is to not check for the return value of prefix <code class="computeroutput"><span class="keyword">operator</span><span class="special">*</span></code>. If <code class="computeroutput"><span class="identifier">Ret</span></code> + is different from the default <code class="computeroutput"><span class="identifier">dont_care</span></code> + type, the return value is checked to be convertible to <code class="computeroutput"><span class="identifier">Ret</span></code>. + Convertible to <code class="computeroutput"><span class="identifier">Ret</span></code> means + that the return value of the operator can be used as argument to a function + expecting <code class="computeroutput"><span class="identifier">Ret</span></code>: +</p> +<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">Ret</span><span class="special">);</span> +<span class="identifier">Rhs</span> <span class="identifier">rhs</span><span class="special">;</span> +<span class="identifier">f</span><span class="special">(*</span><span class="identifier">rhs</span><span class="special">);</span> <span class="comment">// is valid if has_dereference<Rhs, Ret>::value==true</span> +</pre> +<p> + If <code class="computeroutput"><span class="identifier">Ret</span><span class="special">=</span><span class="keyword">void</span></code>, the return type is checked to be exactly + <code class="computeroutput"><span class="keyword">void</span></code>. + </p> +<p> + <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"><span class="preprocessor">#include</span> + <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_dereference</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_operator</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + </p> +<p> + <span class="bold"><strong>Examples:</strong></span> + </p> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_dereference</span><span class="special"><</span><span class="identifier">Rhs</span><span class="special">,</span> <span class="identifier">Ret</span><span class="special">>::</span><span class="identifier">value_type</span></code> is the type <code class="computeroutput"><span class="keyword">bool</span></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_dereference</span><span class="special"><</span><span class="identifier">Rhs</span><span class="special">,</span> <span class="identifier">Ret</span><span class="special">>::</span><span class="identifier">value</span></code> is a <code class="computeroutput"><span class="keyword">bool</span></code> + integral constant expression. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_dereference</span><span class="special"><</span><span class="keyword">int</span><span class="special">*>::</span><span class="identifier">value</span></code> is a <code class="computeroutput"><span class="keyword">bool</span></code> + integral constant expression that evaluates to <code class="computeroutput"><span class="keyword">true</span></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_dereference</span><span class="special"><</span><span class="keyword">long</span><span class="special">*></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_dereference</span><span class="special"><</span><span class="keyword">int</span><span class="special">*,</span> <span class="keyword">int</span><span class="special">></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_dereference</span><span class="special"><</span><span class="keyword">int</span><span class="special">*,</span> <span class="keyword">const</span> + <span class="keyword">int</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_dereference</span><span class="special"><</span><span class="keyword">int</span> <span class="keyword">const</span> <span class="special">*></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_dereference</span><span class="special"><</span><span class="keyword">int</span> <span class="special">*</span> <span class="keyword">const</span><span class="special">></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_dereference</span><span class="special"><</span><span class="keyword">int</span> <span class="keyword">const</span> <span class="special">*</span> <span class="keyword">const</span><span class="special">></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_dereference</span><span class="special"><</span><span class="keyword">int</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_dereference</span><span class="special"><</span><span class="keyword">double</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_dereference</span><span class="special"><</span><span class="keyword">void</span><span class="special">*></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_dereference</span><span class="special"><</span><span class="keyword">const</span> <span class="keyword">int</span><span class="special">*,</span> <span class="keyword">int</span><span class="special">&></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>. + </p></blockquote></div> +<p> + <span class="bold"><strong>See also:</strong></span> <a class="link" href="../category/value_traits/operators.html" title="Operator Type Traits">Operator + Type Traits</a> + </p> +<p> + <span class="bold"><strong>Limitation:</strong></span> + </p> +<div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"> + Requires a compiler with working SFINAE. + </li></ul></div> +<p> + <span class="bold"><strong>Known issues:</strong></span> + </p> +<div class="itemizedlist"><ul class="itemizedlist" type="disc"> +<li class="listitem"> + This trait cannot detect whether prefix <code class="computeroutput"><span class="keyword">operator</span><span class="special">*</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">*</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">Rhs</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_dereference</span><span class="special"><</span><span class="identifier">Rhs</span><span class="special">></span></code> + will produce a compiler error. For this reason <code class="computeroutput"><span class="identifier">has_dereference</span></code> + cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">*</span></code> + or not. +<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">*();</span> <span class="special">};</span> +<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_dereference</span><span class="special"><</span><span class="identifier">A</span><span class="special">>::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator*() is private</span> +</pre> + </li> +<li class="listitem"> + There is an issue if the operator exists only for type <code class="computeroutput"><span class="identifier">A</span></code> and <code class="computeroutput"><span class="identifier">B</span></code> + is convertible to <code class="computeroutput"><span class="identifier">A</span></code>. + In this case, the compiler will report an ambiguous overload. +<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span> +<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">*(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&);</span> +<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span> +<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_dereference</span><span class="special"><</span><span class="identifier">A</span><span class="special">>::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine</span> +<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_dereference</span><span class="special"><</span><span class="identifier">B</span><span class="special">>::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambiguous overload</span> +</pre> + </li> +<li class="listitem"> + There is an issue when applying this trait to template classes. If <code class="computeroutput"><span class="keyword">operator</span><span class="special">*</span></code> + is defined but does not bind for a given template type, it is still detected + by the trait which returns <code class="computeroutput"><span class="keyword">true</span></code> + instead of <code class="computeroutput"><span class="keyword">false</span></code>. Example: + +<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_dereference</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span> +<span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">iostream</span><span class="special">></span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">contains</span> <span class="special">{</span> <span class="identifier">T</span> <span class="identifier">data</span><span class="special">;</span> <span class="special">};</span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">*(</span><span class="keyword">const</span> <span class="identifier">contains</span><span class="special"><</span><span class="identifier">T</span><span class="special">></span> <span class="special">&</span><span class="identifier">rhs</span><span class="special">)</span> <span class="special">{</span> + <span class="keyword">return</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">rhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">);</span> +<span class="special">}</span> + +<span class="keyword">class</span> <span class="identifier">bad</span> <span class="special">{</span> <span class="special">};</span> +<span class="keyword">class</span> <span class="identifier">good</span> <span class="special">{</span> <span class="special">};</span> +<span class="keyword">bool</span> <span class="identifier">f</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">good</span><span class="special">&)</span> <span class="special">{</span> <span class="special">}</span> + +<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span> <span class="special">{</span> + <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special"><<</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">boolalpha</span><span class="special">;</span> + <span class="comment">// works fine for contains<good></span> + <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special"><<</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_dereference</span><span class="special"><</span> <span class="identifier">contains</span><span class="special"><</span> <span class="identifier">good</span> <span class="special">></span> <span class="special">>::</span><span class="identifier">value</span><span class="special"><<</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true</span> + <span class="identifier">contains</span><span class="special"><</span><span class="identifier">good</span><span class="special">></span> <span class="identifier">g</span><span class="special">;</span> + <span class="special">*</span><span class="identifier">g</span><span class="special">;</span> <span class="comment">// ok</span> + <span class="comment">// does not work for contains<bad></span> + <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special"><<</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_dereference</span><span class="special"><</span> <span class="identifier">contains</span><span class="special"><</span> <span class="identifier">bad</span> <span class="special">></span> <span class="special">>::</span><span class="identifier">value</span><span class="special"><<</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true, should be false</span> + <span class="identifier">contains</span><span class="special"><</span><span class="identifier">bad</span><span class="special">></span> <span class="identifier">b</span><span class="special">;</span> + <span class="special">*</span><span class="identifier">b</span><span class="special">;</span> <span class="comment">// compile time error</span> + <span class="keyword">return</span> <span class="number">0</span><span class="special">;</span> +<span class="special">}</span> +</pre> + </li> +<li class="listitem"> + <code class="computeroutput"><span class="keyword">volatile</span></code> qualifier is not + properly handled and would lead to undefined behavior + </li> +</ul></div> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="has_complement.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="has_divides.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/reference/has_divides.html b/libs/type_traits/doc/html/boost_typetraits/reference/has_divides.html new file mode 100644 index 0000000000..cfe31af8af --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/reference/has_divides.html @@ -0,0 +1,196 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>has_divides</title> +<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../reference.html" title="Alphabetical Reference"> +<link rel="prev" href="has_dereference.html" title="has_dereference"> +<link rel="next" href="has_divides_assign.html" title="has_divides_assign"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td> +<td align="center"><a href="../../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="has_dereference.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="has_divides_assign.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h3 class="title"> +<a name="boost_typetraits.reference.has_divides"></a><a class="link" href="has_divides.html" title="has_divides">has_divides</a> +</h3></div></div></div> +<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">Lhs</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Rhs</span><span class="special">=</span><span class="identifier">Lhs</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Ret</span><span class="special">=</span><span class="identifier">dont_care</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">has_divides</span> <span class="special">:</span> <span class="keyword">public</span> <em class="replaceable"><code><a class="link" href="integral_constant.html" title="integral_constant">true_type</a>-or-<a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code></em> <span class="special">{};</span> +</pre> +<p> + <span class="bold"><strong>Inherits:</strong></span> If (i) <code class="computeroutput"><span class="identifier">lhs</span></code> + of type <code class="computeroutput"><span class="identifier">Lhs</span></code> and <code class="computeroutput"><span class="identifier">rhs</span></code> of type <code class="computeroutput"><span class="identifier">Rhs</span></code> + can be used in expression <code class="computeroutput"><span class="identifier">lhs</span><span class="special">/</span><span class="identifier">rhs</span></code>, and + (ii) <code class="computeroutput"><span class="identifier">Ret</span><span class="special">=</span><span class="identifier">dont_care</span></code> or the result of expression + <code class="computeroutput"><span class="identifier">lhs</span><span class="special">/</span><span class="identifier">rhs</span></code> is convertible to <code class="computeroutput"><span class="identifier">Ret</span></code> + then inherits from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>, + otherwise inherits from <a class="link" href="integral_constant.html" title="integral_constant">false_type</a>. + </p> +<p> + The default behaviour (<code class="computeroutput"><span class="identifier">Ret</span><span class="special">=</span><span class="identifier">dont_care</span></code>) + is to not check for the return value of binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">/</span></code>. If <code class="computeroutput"><span class="identifier">Ret</span></code> + is different from the default <code class="computeroutput"><span class="identifier">dont_care</span></code> + type, the return value is checked to be convertible to <code class="computeroutput"><span class="identifier">Ret</span></code>. + Convertible to <code class="computeroutput"><span class="identifier">Ret</span></code> means + that the return value of the operator can be used as argument to a function + expecting <code class="computeroutput"><span class="identifier">Ret</span></code>: +</p> +<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">Ret</span><span class="special">);</span> +<span class="identifier">Lhs</span> <span class="identifier">lhs</span><span class="special">;</span> +<span class="identifier">Rhs</span> <span class="identifier">rhs</span><span class="special">;</span> +<span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">/</span><span class="identifier">rhs</span><span class="special">);</span> <span class="comment">// is valid if has_divides<Lhs, Rhs, Ret>::value==true</span> +</pre> +<p> + If <code class="computeroutput"><span class="identifier">Ret</span><span class="special">=</span><span class="keyword">void</span></code>, the return type is checked to be exactly + <code class="computeroutput"><span class="keyword">void</span></code>. + </p> +<p> + <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"><span class="preprocessor">#include</span> + <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_divides</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_operator</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + </p> +<p> + <span class="bold"><strong>Examples:</strong></span> + </p> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_divides</span><span class="special"><</span><span class="identifier">Lhs</span><span class="special">,</span> <span class="identifier">Rhs</span><span class="special">,</span> <span class="identifier">Ret</span><span class="special">>::</span><span class="identifier">value_type</span></code> is the type <code class="computeroutput"><span class="keyword">bool</span></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_divides</span><span class="special"><</span><span class="identifier">Lhs</span><span class="special">,</span> <span class="identifier">Rhs</span><span class="special">,</span> <span class="identifier">Ret</span><span class="special">>::</span><span class="identifier">value</span></code> is a <code class="computeroutput"><span class="keyword">bool</span></code> + integral constant expression. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_divides</span><span class="special"><</span><span class="keyword">int</span><span class="special">>::</span><span class="identifier">value</span></code> is a <code class="computeroutput"><span class="keyword">bool</span></code> + integral constant expression that evaluates to <code class="computeroutput"><span class="keyword">true</span></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_divides</span><span class="special"><</span><span class="keyword">long</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_divides</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_divides</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="keyword">long</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_divides</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">double</span><span class="special">></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_divides</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">int</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_divides</span><span class="special"><</span><span class="keyword">const</span> <span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">>::</span><span class="identifier">value</span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_divides</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>. + </p></blockquote></div> +<p> + <span class="bold"><strong>See also:</strong></span> <a class="link" href="../category/value_traits/operators.html" title="Operator Type Traits">Operator + Type Traits</a> + </p> +<p> + <span class="bold"><strong>Limitation:</strong></span> + </p> +<div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"> + Requires a compiler with working SFINAE. + </li></ul></div> +<p> + <span class="bold"><strong>Known issues:</strong></span> + </p> +<div class="itemizedlist"><ul class="itemizedlist" type="disc"> +<li class="listitem"> + This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">/</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">/</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">Lhs</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_divides</span><span class="special"><</span><span class="identifier">Lhs</span><span class="special">></span></code> + will produce a compiler error. For this reason <code class="computeroutput"><span class="identifier">has_divides</span></code> + cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">/</span></code> + or not. +<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">/(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&);</span> <span class="special">};</span> +<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_divides</span><span class="special"><</span><span class="identifier">A</span><span class="special">>::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator/(const A&) is private</span> +</pre> + </li> +<li class="listitem"> + There is an issue if the operator exists only for type <code class="computeroutput"><span class="identifier">A</span></code> and <code class="computeroutput"><span class="identifier">B</span></code> + is convertible to <code class="computeroutput"><span class="identifier">A</span></code>. + In this case, the compiler will report an ambiguous overload. +<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span> +<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">/(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&,</span> <span class="keyword">const</span> <span class="identifier">A</span><span class="special">&);</span> +<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span> +<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_divides</span><span class="special"><</span><span class="identifier">A</span><span class="special">>::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine</span> +<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_divides</span><span class="special"><</span><span class="identifier">B</span><span class="special">>::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambiguous overload</span> +</pre> + </li> +<li class="listitem"> + There is an issue when applying this trait to template classes. If <code class="computeroutput"><span class="keyword">operator</span><span class="special">/</span></code> + is defined but does not bind for a given template type, it is still detected + by the trait which returns <code class="computeroutput"><span class="keyword">true</span></code> + instead of <code class="computeroutput"><span class="keyword">false</span></code>. Example: + +<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_divides</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span> +<span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">iostream</span><span class="special">></span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">contains</span> <span class="special">{</span> <span class="identifier">T</span> <span class="identifier">data</span><span class="special">;</span> <span class="special">};</span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">/(</span><span class="keyword">const</span> <span class="identifier">contains</span><span class="special"><</span><span class="identifier">T</span><span class="special">></span> <span class="special">&</span><span class="identifier">lhs</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">contains</span><span class="special"><</span><span class="identifier">T</span><span class="special">></span> <span class="special">&</span><span class="identifier">rhs</span><span class="special">)</span> <span class="special">{</span> + <span class="keyword">return</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">,</span> <span class="identifier">rhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">);</span> +<span class="special">}</span> + +<span class="keyword">class</span> <span class="identifier">bad</span> <span class="special">{</span> <span class="special">};</span> +<span class="keyword">class</span> <span class="identifier">good</span> <span class="special">{</span> <span class="special">};</span> +<span class="keyword">bool</span> <span class="identifier">f</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">good</span><span class="special">&,</span> <span class="keyword">const</span> <span class="identifier">good</span><span class="special">&)</span> <span class="special">{</span> <span class="special">}</span> + +<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span> <span class="special">{</span> + <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special"><<</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">boolalpha</span><span class="special">;</span> + <span class="comment">// works fine for contains<good></span> + <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special"><<</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_divides</span><span class="special"><</span> <span class="identifier">contains</span><span class="special"><</span> <span class="identifier">good</span> <span class="special">></span> <span class="special">>::</span><span class="identifier">value</span><span class="special"><<</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true</span> + <span class="identifier">contains</span><span class="special"><</span><span class="identifier">good</span><span class="special">></span> <span class="identifier">g</span><span class="special">;</span> + <span class="identifier">g</span><span class="special">/</span><span class="identifier">g</span><span class="special">;</span> <span class="comment">// ok</span> + <span class="comment">// does not work for contains<bad></span> + <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special"><<</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_divides</span><span class="special"><</span> <span class="identifier">contains</span><span class="special"><</span> <span class="identifier">bad</span> <span class="special">></span> <span class="special">>::</span><span class="identifier">value</span><span class="special"><<</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true, should be false</span> + <span class="identifier">contains</span><span class="special"><</span><span class="identifier">bad</span><span class="special">></span> <span class="identifier">b</span><span class="special">;</span> + <span class="identifier">b</span><span class="special">/</span><span class="identifier">b</span><span class="special">;</span> <span class="comment">// compile time error</span> + <span class="keyword">return</span> <span class="number">0</span><span class="special">;</span> +<span class="special">}</span> +</pre> + </li> +<li class="listitem"> + <code class="computeroutput"><span class="keyword">volatile</span></code> qualifier is not + properly handled and would lead to undefined behavior + </li> +</ul></div> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="has_dereference.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="has_divides_assign.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/reference/has_divides_assign.html b/libs/type_traits/doc/html/boost_typetraits/reference/has_divides_assign.html new file mode 100644 index 0000000000..59ea88bccc --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/reference/has_divides_assign.html @@ -0,0 +1,198 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>has_divides_assign</title> +<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../reference.html" title="Alphabetical Reference"> +<link rel="prev" href="has_divides.html" title="has_divides"> +<link rel="next" href="has_equal_to.html" title="has_equal_to"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td> +<td align="center"><a href="../../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="has_divides.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="has_equal_to.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h3 class="title"> +<a name="boost_typetraits.reference.has_divides_assign"></a><a class="link" href="has_divides_assign.html" title="has_divides_assign">has_divides_assign</a> +</h3></div></div></div> +<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">Lhs</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Rhs</span><span class="special">=</span><span class="identifier">Lhs</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Ret</span><span class="special">=</span><span class="identifier">dont_care</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">has_divides_assign</span> <span class="special">:</span> <span class="keyword">public</span> <em class="replaceable"><code><a class="link" href="integral_constant.html" title="integral_constant">true_type</a>-or-<a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code></em> <span class="special">{};</span> +</pre> +<p> + <span class="bold"><strong>Inherits:</strong></span> If (i) <code class="computeroutput"><span class="identifier">lhs</span></code> + of type <code class="computeroutput"><span class="identifier">Lhs</span></code> and <code class="computeroutput"><span class="identifier">rhs</span></code> of type <code class="computeroutput"><span class="identifier">Rhs</span></code> + can be used in expression <code class="computeroutput"><span class="identifier">lhs</span><span class="special">/=</span><span class="identifier">rhs</span></code>, + and (ii) <code class="computeroutput"><span class="identifier">Ret</span><span class="special">=</span><span class="identifier">dont_care</span></code> or the result of expression + <code class="computeroutput"><span class="identifier">lhs</span><span class="special">/=</span><span class="identifier">rhs</span></code> is convertible to <code class="computeroutput"><span class="identifier">Ret</span></code> + then inherits from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>, + otherwise inherits from <a class="link" href="integral_constant.html" title="integral_constant">false_type</a>. + </p> +<p> + The default behaviour (<code class="computeroutput"><span class="identifier">Ret</span><span class="special">=</span><span class="identifier">dont_care</span></code>) + is to not check for the return value of binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">/=</span></code>. If <code class="computeroutput"><span class="identifier">Ret</span></code> + is different from the default <code class="computeroutput"><span class="identifier">dont_care</span></code> + type, the return value is checked to be convertible to <code class="computeroutput"><span class="identifier">Ret</span></code>. + Convertible to <code class="computeroutput"><span class="identifier">Ret</span></code> means + that the return value of the operator can be used as argument to a function + expecting <code class="computeroutput"><span class="identifier">Ret</span></code>: +</p> +<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">Ret</span><span class="special">);</span> +<span class="identifier">Lhs</span> <span class="identifier">lhs</span><span class="special">;</span> +<span class="identifier">Rhs</span> <span class="identifier">rhs</span><span class="special">;</span> +<span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">/=</span><span class="identifier">rhs</span><span class="special">);</span> <span class="comment">// is valid if has_divides_assign<Lhs, Rhs, Ret>::value==true</span> +</pre> +<p> + If <code class="computeroutput"><span class="identifier">Ret</span><span class="special">=</span><span class="keyword">void</span></code>, the return type is checked to be exactly + <code class="computeroutput"><span class="keyword">void</span></code>. + </p> +<p> + <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"><span class="preprocessor">#include</span> + <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_divides_assign</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_operator</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + </p> +<p> + <span class="bold"><strong>Examples:</strong></span> + </p> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_divides_assign</span><span class="special"><</span><span class="identifier">Lhs</span><span class="special">,</span> <span class="identifier">Rhs</span><span class="special">,</span> <span class="identifier">Ret</span><span class="special">>::</span><span class="identifier">value_type</span></code> is the type <code class="computeroutput"><span class="keyword">bool</span></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_divides_assign</span><span class="special"><</span><span class="identifier">Lhs</span><span class="special">,</span> <span class="identifier">Rhs</span><span class="special">,</span> <span class="identifier">Ret</span><span class="special">>::</span><span class="identifier">value</span></code> is a <code class="computeroutput"><span class="keyword">bool</span></code> + integral constant expression. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_divides_assign</span><span class="special"><</span><span class="keyword">int</span><span class="special">>::</span><span class="identifier">value</span></code> is a <code class="computeroutput"><span class="keyword">bool</span></code> + integral constant expression that evaluates to <code class="computeroutput"><span class="keyword">true</span></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_divides_assign</span><span class="special"><</span><span class="keyword">long</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_divides_assign</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_divides_assign</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="keyword">long</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_divides_assign</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">double</span><span class="special">></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_divides_assign</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">int</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_divides_assign</span><span class="special"><</span><span class="keyword">const</span> <span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">>::</span><span class="identifier">value</span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_divides_assign</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>. + </p></blockquote></div> +<p> + <span class="bold"><strong>See also:</strong></span> <a class="link" href="../category/value_traits/operators.html" title="Operator Type Traits">Operator + Type Traits</a> + </p> +<p> + <span class="bold"><strong>Limitation:</strong></span> + </p> +<div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"> + Requires a compiler with working SFINAE. + </li></ul></div> +<p> + <span class="bold"><strong>Known issues:</strong></span> + </p> +<div class="itemizedlist"><ul class="itemizedlist" type="disc"> +<li class="listitem"> + This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">/=</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">/=</span></code> + is defined as a private member of <code class="computeroutput"><span class="identifier">Lhs</span></code> + then instantiating <code class="computeroutput"><span class="identifier">has_divides_assign</span><span class="special"><</span><span class="identifier">Lhs</span><span class="special">></span></code> will produce a compiler error. For + this reason <code class="computeroutput"><span class="identifier">has_divides_assign</span></code> + cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">/=</span></code> + or not. +<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">/=(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&);</span> <span class="special">};</span> +<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_divides_assign</span><span class="special"><</span><span class="identifier">A</span><span class="special">>::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator/=(const A&) is private</span> +</pre> + </li> +<li class="listitem"> + There is an issue if the operator exists only for type <code class="computeroutput"><span class="identifier">A</span></code> and <code class="computeroutput"><span class="identifier">B</span></code> + is convertible to <code class="computeroutput"><span class="identifier">A</span></code>. + In this case, the compiler will report an ambiguous overload. +<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span> +<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">/=(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&,</span> <span class="keyword">const</span> <span class="identifier">A</span><span class="special">&);</span> +<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span> +<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_divides_assign</span><span class="special"><</span><span class="identifier">A</span><span class="special">>::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine</span> +<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_divides_assign</span><span class="special"><</span><span class="identifier">B</span><span class="special">>::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambiguous overload</span> +</pre> + </li> +<li class="listitem"> + There is an issue when applying this trait to template classes. If <code class="computeroutput"><span class="keyword">operator</span><span class="special">/=</span></code> + is defined but does not bind for a given template type, it is still detected + by the trait which returns <code class="computeroutput"><span class="keyword">true</span></code> + instead of <code class="computeroutput"><span class="keyword">false</span></code>. Example: + +<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_divides_assign</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span> +<span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">iostream</span><span class="special">></span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">contains</span> <span class="special">{</span> <span class="identifier">T</span> <span class="identifier">data</span><span class="special">;</span> <span class="special">};</span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">/=(</span><span class="keyword">const</span> <span class="identifier">contains</span><span class="special"><</span><span class="identifier">T</span><span class="special">></span> <span class="special">&</span><span class="identifier">lhs</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">contains</span><span class="special"><</span><span class="identifier">T</span><span class="special">></span> <span class="special">&</span><span class="identifier">rhs</span><span class="special">)</span> <span class="special">{</span> + <span class="keyword">return</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">,</span> <span class="identifier">rhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">);</span> +<span class="special">}</span> + +<span class="keyword">class</span> <span class="identifier">bad</span> <span class="special">{</span> <span class="special">};</span> +<span class="keyword">class</span> <span class="identifier">good</span> <span class="special">{</span> <span class="special">};</span> +<span class="keyword">bool</span> <span class="identifier">f</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">good</span><span class="special">&,</span> <span class="keyword">const</span> <span class="identifier">good</span><span class="special">&)</span> <span class="special">{</span> <span class="special">}</span> + +<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span> <span class="special">{</span> + <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special"><<</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">boolalpha</span><span class="special">;</span> + <span class="comment">// works fine for contains<good></span> + <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special"><<</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_divides_assign</span><span class="special"><</span> <span class="identifier">contains</span><span class="special"><</span> <span class="identifier">good</span> <span class="special">></span> <span class="special">>::</span><span class="identifier">value</span><span class="special"><<</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true</span> + <span class="identifier">contains</span><span class="special"><</span><span class="identifier">good</span><span class="special">></span> <span class="identifier">g</span><span class="special">;</span> + <span class="identifier">g</span><span class="special">/=</span><span class="identifier">g</span><span class="special">;</span> <span class="comment">// ok</span> + <span class="comment">// does not work for contains<bad></span> + <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special"><<</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_divides_assign</span><span class="special"><</span> <span class="identifier">contains</span><span class="special"><</span> <span class="identifier">bad</span> <span class="special">></span> <span class="special">>::</span><span class="identifier">value</span><span class="special"><<</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true, should be false</span> + <span class="identifier">contains</span><span class="special"><</span><span class="identifier">bad</span><span class="special">></span> <span class="identifier">b</span><span class="special">;</span> + <span class="identifier">b</span><span class="special">/=</span><span class="identifier">b</span><span class="special">;</span> <span class="comment">// compile time error</span> + <span class="keyword">return</span> <span class="number">0</span><span class="special">;</span> +<span class="special">}</span> +</pre> + </li> +<li class="listitem"> + <code class="computeroutput"><span class="keyword">volatile</span></code> qualifier is not + properly handled and would lead to undefined behavior + </li> +</ul></div> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="has_divides.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="has_equal_to.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/reference/has_equal_to.html b/libs/type_traits/doc/html/boost_typetraits/reference/has_equal_to.html new file mode 100644 index 0000000000..d12ce44c05 --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/reference/has_equal_to.html @@ -0,0 +1,197 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>has_equal_to</title> +<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../reference.html" title="Alphabetical Reference"> +<link rel="prev" href="has_divides_assign.html" title="has_divides_assign"> +<link rel="next" href="has_greater.html" title="has_greater"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td> +<td align="center"><a href="../../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="has_divides_assign.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="has_greater.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h3 class="title"> +<a name="boost_typetraits.reference.has_equal_to"></a><a class="link" href="has_equal_to.html" title="has_equal_to">has_equal_to</a> +</h3></div></div></div> +<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">Lhs</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Rhs</span><span class="special">=</span><span class="identifier">Lhs</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Ret</span><span class="special">=</span><span class="identifier">dont_care</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">has_equal_to</span> <span class="special">:</span> <span class="keyword">public</span> <em class="replaceable"><code><a class="link" href="integral_constant.html" title="integral_constant">true_type</a>-or-<a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code></em> <span class="special">{};</span> +</pre> +<p> + <span class="bold"><strong>Inherits:</strong></span> If (i) <code class="computeroutput"><span class="identifier">lhs</span></code> + of type <code class="computeroutput"><span class="identifier">Lhs</span></code> and <code class="computeroutput"><span class="identifier">rhs</span></code> of type <code class="computeroutput"><span class="identifier">Rhs</span></code> + can be used in expression <code class="computeroutput"><span class="identifier">lhs</span><span class="special">==</span><span class="identifier">rhs</span></code>, + and (ii) <code class="computeroutput"><span class="identifier">Ret</span><span class="special">=</span><span class="identifier">dont_care</span></code> or the result of expression + <code class="computeroutput"><span class="identifier">lhs</span><span class="special">==</span><span class="identifier">rhs</span></code> is convertible to <code class="computeroutput"><span class="identifier">Ret</span></code> + then inherits from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>, + otherwise inherits from <a class="link" href="integral_constant.html" title="integral_constant">false_type</a>. + </p> +<p> + The default behaviour (<code class="computeroutput"><span class="identifier">Ret</span><span class="special">=</span><span class="identifier">dont_care</span></code>) + is to not check for the return value of binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">==</span></code>. If <code class="computeroutput"><span class="identifier">Ret</span></code> + is different from the default <code class="computeroutput"><span class="identifier">dont_care</span></code> + type, the return value is checked to be convertible to <code class="computeroutput"><span class="identifier">Ret</span></code>. + Convertible to <code class="computeroutput"><span class="identifier">Ret</span></code> means + that the return value of the operator can be used as argument to a function + expecting <code class="computeroutput"><span class="identifier">Ret</span></code>: +</p> +<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">Ret</span><span class="special">);</span> +<span class="identifier">Lhs</span> <span class="identifier">lhs</span><span class="special">;</span> +<span class="identifier">Rhs</span> <span class="identifier">rhs</span><span class="special">;</span> +<span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">==</span><span class="identifier">rhs</span><span class="special">);</span> <span class="comment">// is valid if has_equal_to<Lhs, Rhs, Ret>::value==true</span> +</pre> +<p> + If <code class="computeroutput"><span class="identifier">Ret</span><span class="special">=</span><span class="keyword">void</span></code>, the return type is checked to be exactly + <code class="computeroutput"><span class="keyword">void</span></code>. + </p> +<p> + <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"><span class="preprocessor">#include</span> + <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_equal_to</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_operator</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + </p> +<p> + <span class="bold"><strong>Examples:</strong></span> + </p> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_equal_to</span><span class="special"><</span><span class="identifier">Lhs</span><span class="special">,</span> <span class="identifier">Rhs</span><span class="special">,</span> <span class="identifier">Ret</span><span class="special">>::</span><span class="identifier">value_type</span></code> is the type <code class="computeroutput"><span class="keyword">bool</span></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_equal_to</span><span class="special"><</span><span class="identifier">Lhs</span><span class="special">,</span> <span class="identifier">Rhs</span><span class="special">,</span> <span class="identifier">Ret</span><span class="special">>::</span><span class="identifier">value</span></code> is a <code class="computeroutput"><span class="keyword">bool</span></code> + integral constant expression. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_equal_to</span><span class="special"><</span><span class="keyword">int</span><span class="special">>::</span><span class="identifier">value</span></code> is a <code class="computeroutput"><span class="keyword">bool</span></code> + integral constant expression that evaluates to <code class="computeroutput"><span class="keyword">true</span></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_equal_to</span><span class="special"><</span><span class="keyword">long</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_equal_to</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="keyword">bool</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_equal_to</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">bool</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_equal_to</span><span class="special"><</span><span class="keyword">const</span> <span class="keyword">int</span><span class="special">></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_equal_to</span><span class="special"><</span><span class="keyword">int</span><span class="special">*,</span> <span class="keyword">int</span><span class="special">></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_equal_to</span><span class="special"><</span><span class="keyword">int</span><span class="special">*,</span> <span class="keyword">double</span><span class="special">*></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_equal_to</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>. + </p></blockquote></div> +<p> + <span class="bold"><strong>See also:</strong></span> <a class="link" href="../category/value_traits/operators.html" title="Operator Type Traits">Operator + Type Traits</a> + </p> +<p> + <span class="bold"><strong>Limitation:</strong></span> + </p> +<div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"> + Requires a compiler with working SFINAE. + </li></ul></div> +<p> + <span class="bold"><strong>Known issues:</strong></span> + </p> +<div class="itemizedlist"><ul class="itemizedlist" type="disc"> +<li class="listitem"> + This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">==</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">==</span></code> + is defined as a private member of <code class="computeroutput"><span class="identifier">Lhs</span></code> + then instantiating <code class="computeroutput"><span class="identifier">has_equal_to</span><span class="special"><</span><span class="identifier">Lhs</span><span class="special">></span></code> will produce a compiler error. For + this reason <code class="computeroutput"><span class="identifier">has_equal_to</span></code> + cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">==</span></code> + or not. +<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">==(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&);</span> <span class="special">};</span> +<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_equal_to</span><span class="special"><</span><span class="identifier">A</span><span class="special">>::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator==(const A&) is private</span> +</pre> + </li> +<li class="listitem"> + There is an issue if the operator exists only for type <code class="computeroutput"><span class="identifier">A</span></code> and <code class="computeroutput"><span class="identifier">B</span></code> + is convertible to <code class="computeroutput"><span class="identifier">A</span></code>. + In this case, the compiler will report an ambiguous overload. +<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span> +<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">==(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&,</span> <span class="keyword">const</span> <span class="identifier">A</span><span class="special">&);</span> +<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span> +<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_equal_to</span><span class="special"><</span><span class="identifier">A</span><span class="special">>::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine</span> +<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_equal_to</span><span class="special"><</span><span class="identifier">B</span><span class="special">>::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambiguous overload</span> +</pre> + </li> +<li class="listitem"> + There is an issue when applying this trait to template classes. If <code class="computeroutput"><span class="keyword">operator</span><span class="special">==</span></code> + is defined but does not bind for a given template type, it is still detected + by the trait which returns <code class="computeroutput"><span class="keyword">true</span></code> + instead of <code class="computeroutput"><span class="keyword">false</span></code>. Example: + +<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_equal_to</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span> +<span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">iostream</span><span class="special">></span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">contains</span> <span class="special">{</span> <span class="identifier">T</span> <span class="identifier">data</span><span class="special">;</span> <span class="special">};</span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">==(</span><span class="keyword">const</span> <span class="identifier">contains</span><span class="special"><</span><span class="identifier">T</span><span class="special">></span> <span class="special">&</span><span class="identifier">lhs</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">contains</span><span class="special"><</span><span class="identifier">T</span><span class="special">></span> <span class="special">&</span><span class="identifier">rhs</span><span class="special">)</span> <span class="special">{</span> + <span class="keyword">return</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">,</span> <span class="identifier">rhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">);</span> +<span class="special">}</span> + +<span class="keyword">class</span> <span class="identifier">bad</span> <span class="special">{</span> <span class="special">};</span> +<span class="keyword">class</span> <span class="identifier">good</span> <span class="special">{</span> <span class="special">};</span> +<span class="keyword">bool</span> <span class="identifier">f</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">good</span><span class="special">&,</span> <span class="keyword">const</span> <span class="identifier">good</span><span class="special">&)</span> <span class="special">{</span> <span class="special">}</span> + +<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span> <span class="special">{</span> + <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special"><<</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">boolalpha</span><span class="special">;</span> + <span class="comment">// works fine for contains<good></span> + <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special"><<</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_equal_to</span><span class="special"><</span> <span class="identifier">contains</span><span class="special"><</span> <span class="identifier">good</span> <span class="special">></span> <span class="special">>::</span><span class="identifier">value</span><span class="special"><<</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true</span> + <span class="identifier">contains</span><span class="special"><</span><span class="identifier">good</span><span class="special">></span> <span class="identifier">g</span><span class="special">;</span> + <span class="identifier">g</span><span class="special">==</span><span class="identifier">g</span><span class="special">;</span> <span class="comment">// ok</span> + <span class="comment">// does not work for contains<bad></span> + <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special"><<</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_equal_to</span><span class="special"><</span> <span class="identifier">contains</span><span class="special"><</span> <span class="identifier">bad</span> <span class="special">></span> <span class="special">>::</span><span class="identifier">value</span><span class="special"><<</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true, should be false</span> + <span class="identifier">contains</span><span class="special"><</span><span class="identifier">bad</span><span class="special">></span> <span class="identifier">b</span><span class="special">;</span> + <span class="identifier">b</span><span class="special">==</span><span class="identifier">b</span><span class="special">;</span> <span class="comment">// compile time error</span> + <span class="keyword">return</span> <span class="number">0</span><span class="special">;</span> +<span class="special">}</span> +</pre> + </li> +<li class="listitem"> + <code class="computeroutput"><span class="keyword">volatile</span></code> qualifier is not + properly handled and would lead to undefined behavior + </li> +</ul></div> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="has_divides_assign.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="has_greater.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/reference/has_greater.html b/libs/type_traits/doc/html/boost_typetraits/reference/has_greater.html new file mode 100644 index 0000000000..428e6cf6af --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/reference/has_greater.html @@ -0,0 +1,197 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>has_greater</title> +<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../reference.html" title="Alphabetical Reference"> +<link rel="prev" href="has_equal_to.html" title="has_equal_to"> +<link rel="next" href="has_greater_equal.html" title="has_greater_equal"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td> +<td align="center"><a href="../../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="has_equal_to.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="has_greater_equal.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h3 class="title"> +<a name="boost_typetraits.reference.has_greater"></a><a class="link" href="has_greater.html" title="has_greater">has_greater</a> +</h3></div></div></div> +<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">Lhs</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Rhs</span><span class="special">=</span><span class="identifier">Lhs</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Ret</span><span class="special">=</span><span class="identifier">dont_care</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">has_greater</span> <span class="special">:</span> <span class="keyword">public</span> <em class="replaceable"><code><a class="link" href="integral_constant.html" title="integral_constant">true_type</a>-or-<a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code></em> <span class="special">{};</span> +</pre> +<p> + <span class="bold"><strong>Inherits:</strong></span> If (i) <code class="computeroutput"><span class="identifier">lhs</span></code> + of type <code class="computeroutput"><span class="identifier">Lhs</span></code> and <code class="computeroutput"><span class="identifier">rhs</span></code> of type <code class="computeroutput"><span class="identifier">Rhs</span></code> + can be used in expression <code class="computeroutput"><span class="identifier">lhs</span><span class="special">></span><span class="identifier">rhs</span></code>, + and (ii) <code class="computeroutput"><span class="identifier">Ret</span><span class="special">=</span><span class="identifier">dont_care</span></code> or the result of expression + <code class="computeroutput"><span class="identifier">lhs</span><span class="special">></span><span class="identifier">rhs</span></code> is convertible to <code class="computeroutput"><span class="identifier">Ret</span></code> + then inherits from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>, + otherwise inherits from <a class="link" href="integral_constant.html" title="integral_constant">false_type</a>. + </p> +<p> + The default behaviour (<code class="computeroutput"><span class="identifier">Ret</span><span class="special">=</span><span class="identifier">dont_care</span></code>) + is to not check for the return value of binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">></span></code>. If <code class="computeroutput"><span class="identifier">Ret</span></code> + is different from the default <code class="computeroutput"><span class="identifier">dont_care</span></code> + type, the return value is checked to be convertible to <code class="computeroutput"><span class="identifier">Ret</span></code>. + Convertible to <code class="computeroutput"><span class="identifier">Ret</span></code> means + that the return value of the operator can be used as argument to a function + expecting <code class="computeroutput"><span class="identifier">Ret</span></code>: +</p> +<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">Ret</span><span class="special">);</span> +<span class="identifier">Lhs</span> <span class="identifier">lhs</span><span class="special">;</span> +<span class="identifier">Rhs</span> <span class="identifier">rhs</span><span class="special">;</span> +<span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">></span><span class="identifier">rhs</span><span class="special">);</span> <span class="comment">// is valid if has_greater<Lhs, Rhs, Ret>::value==true</span> +</pre> +<p> + If <code class="computeroutput"><span class="identifier">Ret</span><span class="special">=</span><span class="keyword">void</span></code>, the return type is checked to be exactly + <code class="computeroutput"><span class="keyword">void</span></code>. + </p> +<p> + <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"><span class="preprocessor">#include</span> + <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_greater</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_operator</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + </p> +<p> + <span class="bold"><strong>Examples:</strong></span> + </p> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_greater</span><span class="special"><</span><span class="identifier">Lhs</span><span class="special">,</span> <span class="identifier">Rhs</span><span class="special">,</span> <span class="identifier">Ret</span><span class="special">>::</span><span class="identifier">value_type</span></code> is the type <code class="computeroutput"><span class="keyword">bool</span></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_greater</span><span class="special"><</span><span class="identifier">Lhs</span><span class="special">,</span> <span class="identifier">Rhs</span><span class="special">,</span> <span class="identifier">Ret</span><span class="special">>::</span><span class="identifier">value</span></code> is a <code class="computeroutput"><span class="keyword">bool</span></code> + integral constant expression. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_greater</span><span class="special"><</span><span class="keyword">int</span><span class="special">>::</span><span class="identifier">value</span></code> is a <code class="computeroutput"><span class="keyword">bool</span></code> + integral constant expression that evaluates to <code class="computeroutput"><span class="keyword">true</span></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_greater</span><span class="special"><</span><span class="keyword">long</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_greater</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="keyword">bool</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_greater</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">bool</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_greater</span><span class="special"><</span><span class="keyword">const</span> <span class="keyword">int</span><span class="special">></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_greater</span><span class="special"><</span><span class="keyword">int</span><span class="special">*,</span> <span class="keyword">int</span><span class="special">></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_greater</span><span class="special"><</span><span class="keyword">int</span><span class="special">*,</span> <span class="keyword">double</span><span class="special">*></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_greater</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>. + </p></blockquote></div> +<p> + <span class="bold"><strong>See also:</strong></span> <a class="link" href="../category/value_traits/operators.html" title="Operator Type Traits">Operator + Type Traits</a> + </p> +<p> + <span class="bold"><strong>Limitation:</strong></span> + </p> +<div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"> + Requires a compiler with working SFINAE. + </li></ul></div> +<p> + <span class="bold"><strong>Known issues:</strong></span> + </p> +<div class="itemizedlist"><ul class="itemizedlist" type="disc"> +<li class="listitem"> + This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">></span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">></span></code> + is defined as a private member of <code class="computeroutput"><span class="identifier">Lhs</span></code> + then instantiating <code class="computeroutput"><span class="identifier">has_greater</span><span class="special"><</span><span class="identifier">Lhs</span><span class="special">></span></code> will produce a compiler error. For + this reason <code class="computeroutput"><span class="identifier">has_greater</span></code> + cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">></span></code> + or not. +<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">>(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&);</span> <span class="special">};</span> +<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_greater</span><span class="special"><</span><span class="identifier">A</span><span class="special">>::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator>(const A&) is private</span> +</pre> + </li> +<li class="listitem"> + There is an issue if the operator exists only for type <code class="computeroutput"><span class="identifier">A</span></code> and <code class="computeroutput"><span class="identifier">B</span></code> + is convertible to <code class="computeroutput"><span class="identifier">A</span></code>. + In this case, the compiler will report an ambiguous overload. +<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span> +<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">>(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&,</span> <span class="keyword">const</span> <span class="identifier">A</span><span class="special">&);</span> +<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span> +<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_greater</span><span class="special"><</span><span class="identifier">A</span><span class="special">>::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine</span> +<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_greater</span><span class="special"><</span><span class="identifier">B</span><span class="special">>::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambiguous overload</span> +</pre> + </li> +<li class="listitem"> + There is an issue when applying this trait to template classes. If <code class="computeroutput"><span class="keyword">operator</span><span class="special">></span></code> + is defined but does not bind for a given template type, it is still detected + by the trait which returns <code class="computeroutput"><span class="keyword">true</span></code> + instead of <code class="computeroutput"><span class="keyword">false</span></code>. Example: + +<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_greater</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span> +<span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">iostream</span><span class="special">></span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">contains</span> <span class="special">{</span> <span class="identifier">T</span> <span class="identifier">data</span><span class="special">;</span> <span class="special">};</span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">>(</span><span class="keyword">const</span> <span class="identifier">contains</span><span class="special"><</span><span class="identifier">T</span><span class="special">></span> <span class="special">&</span><span class="identifier">lhs</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">contains</span><span class="special"><</span><span class="identifier">T</span><span class="special">></span> <span class="special">&</span><span class="identifier">rhs</span><span class="special">)</span> <span class="special">{</span> + <span class="keyword">return</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">,</span> <span class="identifier">rhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">);</span> +<span class="special">}</span> + +<span class="keyword">class</span> <span class="identifier">bad</span> <span class="special">{</span> <span class="special">};</span> +<span class="keyword">class</span> <span class="identifier">good</span> <span class="special">{</span> <span class="special">};</span> +<span class="keyword">bool</span> <span class="identifier">f</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">good</span><span class="special">&,</span> <span class="keyword">const</span> <span class="identifier">good</span><span class="special">&)</span> <span class="special">{</span> <span class="special">}</span> + +<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span> <span class="special">{</span> + <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special"><<</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">boolalpha</span><span class="special">;</span> + <span class="comment">// works fine for contains<good></span> + <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special"><<</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_greater</span><span class="special"><</span> <span class="identifier">contains</span><span class="special"><</span> <span class="identifier">good</span> <span class="special">></span> <span class="special">>::</span><span class="identifier">value</span><span class="special"><<</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true</span> + <span class="identifier">contains</span><span class="special"><</span><span class="identifier">good</span><span class="special">></span> <span class="identifier">g</span><span class="special">;</span> + <span class="identifier">g</span><span class="special">></span><span class="identifier">g</span><span class="special">;</span> <span class="comment">// ok</span> + <span class="comment">// does not work for contains<bad></span> + <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special"><<</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_greater</span><span class="special"><</span> <span class="identifier">contains</span><span class="special"><</span> <span class="identifier">bad</span> <span class="special">></span> <span class="special">>::</span><span class="identifier">value</span><span class="special"><<</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true, should be false</span> + <span class="identifier">contains</span><span class="special"><</span><span class="identifier">bad</span><span class="special">></span> <span class="identifier">b</span><span class="special">;</span> + <span class="identifier">b</span><span class="special">></span><span class="identifier">b</span><span class="special">;</span> <span class="comment">// compile time error</span> + <span class="keyword">return</span> <span class="number">0</span><span class="special">;</span> +<span class="special">}</span> +</pre> + </li> +<li class="listitem"> + <code class="computeroutput"><span class="keyword">volatile</span></code> qualifier is not + properly handled and would lead to undefined behavior + </li> +</ul></div> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="has_equal_to.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="has_greater_equal.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/reference/has_greater_equal.html b/libs/type_traits/doc/html/boost_typetraits/reference/has_greater_equal.html new file mode 100644 index 0000000000..6e86269107 --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/reference/has_greater_equal.html @@ -0,0 +1,197 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>has_greater_equal</title> +<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../reference.html" title="Alphabetical Reference"> +<link rel="prev" href="has_greater.html" title="has_greater"> +<link rel="next" href="has_left_shift.html" title="has_left_shift"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td> +<td align="center"><a href="../../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="has_greater.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="has_left_shift.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h3 class="title"> +<a name="boost_typetraits.reference.has_greater_equal"></a><a class="link" href="has_greater_equal.html" title="has_greater_equal">has_greater_equal</a> +</h3></div></div></div> +<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">Lhs</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Rhs</span><span class="special">=</span><span class="identifier">Lhs</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Ret</span><span class="special">=</span><span class="identifier">dont_care</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">has_greater_equal</span> <span class="special">:</span> <span class="keyword">public</span> <em class="replaceable"><code><a class="link" href="integral_constant.html" title="integral_constant">true_type</a>-or-<a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code></em> <span class="special">{};</span> +</pre> +<p> + <span class="bold"><strong>Inherits:</strong></span> If (i) <code class="computeroutput"><span class="identifier">lhs</span></code> + of type <code class="computeroutput"><span class="identifier">Lhs</span></code> and <code class="computeroutput"><span class="identifier">rhs</span></code> of type <code class="computeroutput"><span class="identifier">Rhs</span></code> + can be used in expression <code class="computeroutput"><span class="identifier">lhs</span><span class="special">>=</span><span class="identifier">rhs</span></code>, + and (ii) <code class="computeroutput"><span class="identifier">Ret</span><span class="special">=</span><span class="identifier">dont_care</span></code> or the result of expression + <code class="computeroutput"><span class="identifier">lhs</span><span class="special">>=</span><span class="identifier">rhs</span></code> is convertible to <code class="computeroutput"><span class="identifier">Ret</span></code> + then inherits from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>, + otherwise inherits from <a class="link" href="integral_constant.html" title="integral_constant">false_type</a>. + </p> +<p> + The default behaviour (<code class="computeroutput"><span class="identifier">Ret</span><span class="special">=</span><span class="identifier">dont_care</span></code>) + is to not check for the return value of binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">>=</span></code>. If <code class="computeroutput"><span class="identifier">Ret</span></code> + is different from the default <code class="computeroutput"><span class="identifier">dont_care</span></code> + type, the return value is checked to be convertible to <code class="computeroutput"><span class="identifier">Ret</span></code>. + Convertible to <code class="computeroutput"><span class="identifier">Ret</span></code> means + that the return value of the operator can be used as argument to a function + expecting <code class="computeroutput"><span class="identifier">Ret</span></code>: +</p> +<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">Ret</span><span class="special">);</span> +<span class="identifier">Lhs</span> <span class="identifier">lhs</span><span class="special">;</span> +<span class="identifier">Rhs</span> <span class="identifier">rhs</span><span class="special">;</span> +<span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">>=</span><span class="identifier">rhs</span><span class="special">);</span> <span class="comment">// is valid if has_greater_equal<Lhs, Rhs, Ret>::value==true</span> +</pre> +<p> + If <code class="computeroutput"><span class="identifier">Ret</span><span class="special">=</span><span class="keyword">void</span></code>, the return type is checked to be exactly + <code class="computeroutput"><span class="keyword">void</span></code>. + </p> +<p> + <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"><span class="preprocessor">#include</span> + <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_greater_equal</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_operator</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + </p> +<p> + <span class="bold"><strong>Examples:</strong></span> + </p> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_greater_equal</span><span class="special"><</span><span class="identifier">Lhs</span><span class="special">,</span> <span class="identifier">Rhs</span><span class="special">,</span> <span class="identifier">Ret</span><span class="special">>::</span><span class="identifier">value_type</span></code> is the type <code class="computeroutput"><span class="keyword">bool</span></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_greater_equal</span><span class="special"><</span><span class="identifier">Lhs</span><span class="special">,</span> <span class="identifier">Rhs</span><span class="special">,</span> <span class="identifier">Ret</span><span class="special">>::</span><span class="identifier">value</span></code> is a <code class="computeroutput"><span class="keyword">bool</span></code> + integral constant expression. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_greater_equal</span><span class="special"><</span><span class="keyword">int</span><span class="special">>::</span><span class="identifier">value</span></code> is a <code class="computeroutput"><span class="keyword">bool</span></code> + integral constant expression that evaluates to <code class="computeroutput"><span class="keyword">true</span></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_greater_equal</span><span class="special"><</span><span class="keyword">long</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_greater_equal</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="keyword">bool</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_greater_equal</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">bool</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_greater_equal</span><span class="special"><</span><span class="keyword">const</span> <span class="keyword">int</span><span class="special">></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_greater_equal</span><span class="special"><</span><span class="keyword">int</span><span class="special">*,</span> <span class="keyword">int</span><span class="special">></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_greater_equal</span><span class="special"><</span><span class="keyword">int</span><span class="special">*,</span> <span class="keyword">double</span><span class="special">*></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_greater_equal</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>. + </p></blockquote></div> +<p> + <span class="bold"><strong>See also:</strong></span> <a class="link" href="../category/value_traits/operators.html" title="Operator Type Traits">Operator + Type Traits</a> + </p> +<p> + <span class="bold"><strong>Limitation:</strong></span> + </p> +<div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"> + Requires a compiler with working SFINAE. + </li></ul></div> +<p> + <span class="bold"><strong>Known issues:</strong></span> + </p> +<div class="itemizedlist"><ul class="itemizedlist" type="disc"> +<li class="listitem"> + This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">>=</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">>=</span></code> + is defined as a private member of <code class="computeroutput"><span class="identifier">Lhs</span></code> + then instantiating <code class="computeroutput"><span class="identifier">has_greater_equal</span><span class="special"><</span><span class="identifier">Lhs</span><span class="special">></span></code> will produce a compiler error. For + this reason <code class="computeroutput"><span class="identifier">has_greater_equal</span></code> + cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">>=</span></code> + or not. +<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">>=(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&);</span> <span class="special">};</span> +<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_greater_equal</span><span class="special"><</span><span class="identifier">A</span><span class="special">>::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator>=(const A&) is private</span> +</pre> + </li> +<li class="listitem"> + There is an issue if the operator exists only for type <code class="computeroutput"><span class="identifier">A</span></code> and <code class="computeroutput"><span class="identifier">B</span></code> + is convertible to <code class="computeroutput"><span class="identifier">A</span></code>. + In this case, the compiler will report an ambiguous overload. +<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span> +<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">>=(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&,</span> <span class="keyword">const</span> <span class="identifier">A</span><span class="special">&);</span> +<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span> +<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_greater_equal</span><span class="special"><</span><span class="identifier">A</span><span class="special">>::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine</span> +<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_greater_equal</span><span class="special"><</span><span class="identifier">B</span><span class="special">>::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambiguous overload</span> +</pre> + </li> +<li class="listitem"> + There is an issue when applying this trait to template classes. If <code class="computeroutput"><span class="keyword">operator</span><span class="special">>=</span></code> + is defined but does not bind for a given template type, it is still detected + by the trait which returns <code class="computeroutput"><span class="keyword">true</span></code> + instead of <code class="computeroutput"><span class="keyword">false</span></code>. Example: + +<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_greater_equal</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span> +<span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">iostream</span><span class="special">></span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">contains</span> <span class="special">{</span> <span class="identifier">T</span> <span class="identifier">data</span><span class="special">;</span> <span class="special">};</span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">>=(</span><span class="keyword">const</span> <span class="identifier">contains</span><span class="special"><</span><span class="identifier">T</span><span class="special">></span> <span class="special">&</span><span class="identifier">lhs</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">contains</span><span class="special"><</span><span class="identifier">T</span><span class="special">></span> <span class="special">&</span><span class="identifier">rhs</span><span class="special">)</span> <span class="special">{</span> + <span class="keyword">return</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">,</span> <span class="identifier">rhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">);</span> +<span class="special">}</span> + +<span class="keyword">class</span> <span class="identifier">bad</span> <span class="special">{</span> <span class="special">};</span> +<span class="keyword">class</span> <span class="identifier">good</span> <span class="special">{</span> <span class="special">};</span> +<span class="keyword">bool</span> <span class="identifier">f</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">good</span><span class="special">&,</span> <span class="keyword">const</span> <span class="identifier">good</span><span class="special">&)</span> <span class="special">{</span> <span class="special">}</span> + +<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span> <span class="special">{</span> + <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special"><<</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">boolalpha</span><span class="special">;</span> + <span class="comment">// works fine for contains<good></span> + <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special"><<</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_greater_equal</span><span class="special"><</span> <span class="identifier">contains</span><span class="special"><</span> <span class="identifier">good</span> <span class="special">></span> <span class="special">>::</span><span class="identifier">value</span><span class="special"><<</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true</span> + <span class="identifier">contains</span><span class="special"><</span><span class="identifier">good</span><span class="special">></span> <span class="identifier">g</span><span class="special">;</span> + <span class="identifier">g</span><span class="special">>=</span><span class="identifier">g</span><span class="special">;</span> <span class="comment">// ok</span> + <span class="comment">// does not work for contains<bad></span> + <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special"><<</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_greater_equal</span><span class="special"><</span> <span class="identifier">contains</span><span class="special"><</span> <span class="identifier">bad</span> <span class="special">></span> <span class="special">>::</span><span class="identifier">value</span><span class="special"><<</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true, should be false</span> + <span class="identifier">contains</span><span class="special"><</span><span class="identifier">bad</span><span class="special">></span> <span class="identifier">b</span><span class="special">;</span> + <span class="identifier">b</span><span class="special">>=</span><span class="identifier">b</span><span class="special">;</span> <span class="comment">// compile time error</span> + <span class="keyword">return</span> <span class="number">0</span><span class="special">;</span> +<span class="special">}</span> +</pre> + </li> +<li class="listitem"> + <code class="computeroutput"><span class="keyword">volatile</span></code> qualifier is not + properly handled and would lead to undefined behavior + </li> +</ul></div> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="has_greater.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="has_left_shift.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/reference/has_left_shift.html b/libs/type_traits/doc/html/boost_typetraits/reference/has_left_shift.html new file mode 100644 index 0000000000..536a82d7c8 --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/reference/has_left_shift.html @@ -0,0 +1,204 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>has_left_shift</title> +<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../reference.html" title="Alphabetical Reference"> +<link rel="prev" href="has_greater_equal.html" title="has_greater_equal"> +<link rel="next" href="has_left_shift_assign.html" title="has_left_shift_assign"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td> +<td align="center"><a href="../../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="has_greater_equal.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="has_left_shift_assign.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h3 class="title"> +<a name="boost_typetraits.reference.has_left_shift"></a><a class="link" href="has_left_shift.html" title="has_left_shift">has_left_shift</a> +</h3></div></div></div> +<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">Lhs</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Rhs</span><span class="special">=</span><span class="identifier">Lhs</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Ret</span><span class="special">=</span><span class="identifier">dont_care</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">has_left_shift</span> <span class="special">:</span> <span class="keyword">public</span> <em class="replaceable"><code><a class="link" href="integral_constant.html" title="integral_constant">true_type</a>-or-<a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code></em> <span class="special">{};</span> +</pre> +<p> + <span class="bold"><strong>Inherits:</strong></span> If (i) <code class="computeroutput"><span class="identifier">lhs</span></code> + of type <code class="computeroutput"><span class="identifier">Lhs</span></code> and <code class="computeroutput"><span class="identifier">rhs</span></code> of type <code class="computeroutput"><span class="identifier">Rhs</span></code> + can be used in expression <code class="computeroutput"><span class="identifier">lhs</span><span class="special"><<</span><span class="identifier">rhs</span></code>, + and (ii) <code class="computeroutput"><span class="identifier">Ret</span><span class="special">=</span><span class="identifier">dont_care</span></code> or the result of expression + <code class="computeroutput"><span class="identifier">lhs</span><span class="special"><<</span><span class="identifier">rhs</span></code> is convertible to <code class="computeroutput"><span class="identifier">Ret</span></code> + then inherits from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>, + otherwise inherits from <a class="link" href="integral_constant.html" title="integral_constant">false_type</a>. + </p> +<p> + The default behaviour (<code class="computeroutput"><span class="identifier">Ret</span><span class="special">=</span><span class="identifier">dont_care</span></code>) + is to not check for the return value of binary <code class="computeroutput"><span class="keyword">operator</span><span class="special"><<</span></code>. If <code class="computeroutput"><span class="identifier">Ret</span></code> + is different from the default <code class="computeroutput"><span class="identifier">dont_care</span></code> + type, the return value is checked to be convertible to <code class="computeroutput"><span class="identifier">Ret</span></code>. + Convertible to <code class="computeroutput"><span class="identifier">Ret</span></code> means + that the return value of the operator can be used as argument to a function + expecting <code class="computeroutput"><span class="identifier">Ret</span></code>: +</p> +<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">Ret</span><span class="special">);</span> +<span class="identifier">Lhs</span> <span class="identifier">lhs</span><span class="special">;</span> +<span class="identifier">Rhs</span> <span class="identifier">rhs</span><span class="special">;</span> +<span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special"><<</span><span class="identifier">rhs</span><span class="special">);</span> <span class="comment">// is valid if has_left_shift<Lhs, Rhs, Ret>::value==true</span> +</pre> +<p> + If <code class="computeroutput"><span class="identifier">Ret</span><span class="special">=</span><span class="keyword">void</span></code>, the return type is checked to be exactly + <code class="computeroutput"><span class="keyword">void</span></code>. + </p> +<p> + <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"><span class="preprocessor">#include</span> + <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_left_shift</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_operator</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + </p> +<p> + <span class="bold"><strong>Examples:</strong></span> + </p> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_left_shift</span><span class="special"><</span><span class="identifier">Lhs</span><span class="special">,</span> <span class="identifier">Rhs</span><span class="special">,</span> <span class="identifier">Ret</span><span class="special">>::</span><span class="identifier">value_type</span></code> is the type <code class="computeroutput"><span class="keyword">bool</span></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_left_shift</span><span class="special"><</span><span class="identifier">Lhs</span><span class="special">,</span> <span class="identifier">Rhs</span><span class="special">,</span> <span class="identifier">Ret</span><span class="special">>::</span><span class="identifier">value</span></code> is a <code class="computeroutput"><span class="keyword">bool</span></code> + integral constant expression. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_left_shift</span><span class="special"><</span><span class="keyword">int</span><span class="special">>::</span><span class="identifier">value</span></code> is a <code class="computeroutput"><span class="keyword">bool</span></code> + integral constant expression that evaluates to <code class="computeroutput"><span class="keyword">true</span></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_left_shift</span><span class="special"><</span><span class="keyword">long</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_left_shift</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_left_shift</span><span class="special"><</span><span class="keyword">const</span> <span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_left_shift</span><span class="special"><</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">ostream</span><span class="special">,</span> <span class="keyword">int</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_left_shift</span><span class="special"><</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">ostream</span><span class="special">,</span> <span class="keyword">char</span><span class="special">*,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">ostream</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_left_shift</span><span class="special"><</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">ostream</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_left_shift</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">bool</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_left_shift</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>. + </p></blockquote></div> +<p> + <span class="bold"><strong>See also:</strong></span> <a class="link" href="../category/value_traits/operators.html" title="Operator Type Traits">Operator + Type Traits</a> + </p> +<p> + <span class="bold"><strong>Limitation:</strong></span> + </p> +<div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"> + Requires a compiler with working SFINAE. + </li></ul></div> +<p> + <span class="bold"><strong>Known issues:</strong></span> + </p> +<div class="itemizedlist"><ul class="itemizedlist" type="disc"> +<li class="listitem"> + This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special"><<</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special"><<</span></code> + is defined as a private member of <code class="computeroutput"><span class="identifier">Lhs</span></code> + then instantiating <code class="computeroutput"><span class="identifier">has_left_shift</span><span class="special"><</span><span class="identifier">Lhs</span><span class="special">></span></code> will produce a compiler error. For + this reason <code class="computeroutput"><span class="identifier">has_left_shift</span></code> + cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special"><<</span></code> + or not. +<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special"><<(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&);</span> <span class="special">};</span> +<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_left_shift</span><span class="special"><</span><span class="identifier">A</span><span class="special">>::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator<<(const A&) is private</span> +</pre> + </li> +<li class="listitem"> + There is an issue if the operator exists only for type <code class="computeroutput"><span class="identifier">A</span></code> and <code class="computeroutput"><span class="identifier">B</span></code> + is convertible to <code class="computeroutput"><span class="identifier">A</span></code>. + In this case, the compiler will report an ambiguous overload. +<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span> +<span class="keyword">void</span> <span class="keyword">operator</span><span class="special"><<(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&,</span> <span class="keyword">const</span> <span class="identifier">A</span><span class="special">&);</span> +<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span> +<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_left_shift</span><span class="special"><</span><span class="identifier">A</span><span class="special">>::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine</span> +<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_left_shift</span><span class="special"><</span><span class="identifier">B</span><span class="special">>::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambiguous overload</span> +</pre> + </li> +<li class="listitem"> + There is an issue when applying this trait to template classes. If <code class="computeroutput"><span class="keyword">operator</span><span class="special"><<</span></code> + is defined but does not bind for a given template type, it is still detected + by the trait which returns <code class="computeroutput"><span class="keyword">true</span></code> + instead of <code class="computeroutput"><span class="keyword">false</span></code>. Example: + +<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_left_shift</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span> +<span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">iostream</span><span class="special">></span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">contains</span> <span class="special">{</span> <span class="identifier">T</span> <span class="identifier">data</span><span class="special">;</span> <span class="special">};</span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">bool</span> <span class="keyword">operator</span><span class="special"><<(</span><span class="keyword">const</span> <span class="identifier">contains</span><span class="special"><</span><span class="identifier">T</span><span class="special">></span> <span class="special">&</span><span class="identifier">lhs</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">contains</span><span class="special"><</span><span class="identifier">T</span><span class="special">></span> <span class="special">&</span><span class="identifier">rhs</span><span class="special">)</span> <span class="special">{</span> + <span class="keyword">return</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">,</span> <span class="identifier">rhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">);</span> +<span class="special">}</span> + +<span class="keyword">class</span> <span class="identifier">bad</span> <span class="special">{</span> <span class="special">};</span> +<span class="keyword">class</span> <span class="identifier">good</span> <span class="special">{</span> <span class="special">};</span> +<span class="keyword">bool</span> <span class="identifier">f</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">good</span><span class="special">&,</span> <span class="keyword">const</span> <span class="identifier">good</span><span class="special">&)</span> <span class="special">{</span> <span class="special">}</span> + +<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span> <span class="special">{</span> + <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special"><<</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">boolalpha</span><span class="special">;</span> + <span class="comment">// works fine for contains<good></span> + <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special"><<</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_left_shift</span><span class="special"><</span> <span class="identifier">contains</span><span class="special"><</span> <span class="identifier">good</span> <span class="special">></span> <span class="special">>::</span><span class="identifier">value</span><span class="special"><<</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true</span> + <span class="identifier">contains</span><span class="special"><</span><span class="identifier">good</span><span class="special">></span> <span class="identifier">g</span><span class="special">;</span> + <span class="identifier">g</span><span class="special"><<</span><span class="identifier">g</span><span class="special">;</span> <span class="comment">// ok</span> + <span class="comment">// does not work for contains<bad></span> + <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special"><<</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_left_shift</span><span class="special"><</span> <span class="identifier">contains</span><span class="special"><</span> <span class="identifier">bad</span> <span class="special">></span> <span class="special">>::</span><span class="identifier">value</span><span class="special"><<</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true, should be false</span> + <span class="identifier">contains</span><span class="special"><</span><span class="identifier">bad</span><span class="special">></span> <span class="identifier">b</span><span class="special">;</span> + <span class="identifier">b</span><span class="special"><<</span><span class="identifier">b</span><span class="special">;</span> <span class="comment">// compile time error</span> + <span class="keyword">return</span> <span class="number">0</span><span class="special">;</span> +<span class="special">}</span> +</pre> + </li> +<li class="listitem"> + <code class="computeroutput"><span class="keyword">volatile</span></code> qualifier is not + properly handled and would lead to undefined behavior + </li> +</ul></div> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="has_greater_equal.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="has_left_shift_assign.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/reference/has_left_shift_assign.html b/libs/type_traits/doc/html/boost_typetraits/reference/has_left_shift_assign.html new file mode 100644 index 0000000000..ccd2845d32 --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/reference/has_left_shift_assign.html @@ -0,0 +1,192 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>has_left_shift_assign</title> +<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../reference.html" title="Alphabetical Reference"> +<link rel="prev" href="has_left_shift.html" title="has_left_shift"> +<link rel="next" href="has_less.html" title="has_less"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td> +<td align="center"><a href="../../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="has_left_shift.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="has_less.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h3 class="title"> +<a name="boost_typetraits.reference.has_left_shift_assign"></a><a class="link" href="has_left_shift_assign.html" title="has_left_shift_assign">has_left_shift_assign</a> +</h3></div></div></div> +<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">Lhs</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Rhs</span><span class="special">=</span><span class="identifier">Lhs</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Ret</span><span class="special">=</span><span class="identifier">dont_care</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">has_left_shift_assign</span> <span class="special">:</span> <span class="keyword">public</span> <em class="replaceable"><code><a class="link" href="integral_constant.html" title="integral_constant">true_type</a>-or-<a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code></em> <span class="special">{};</span> +</pre> +<p> + <span class="bold"><strong>Inherits:</strong></span> If (i) <code class="computeroutput"><span class="identifier">lhs</span></code> + of type <code class="computeroutput"><span class="identifier">Lhs</span></code> and <code class="computeroutput"><span class="identifier">rhs</span></code> of type <code class="computeroutput"><span class="identifier">Rhs</span></code> + can be used in expression <code class="computeroutput"><span class="identifier">lhs</span><span class="special"><<=</span><span class="identifier">rhs</span></code>, + and (ii) <code class="computeroutput"><span class="identifier">Ret</span><span class="special">=</span><span class="identifier">dont_care</span></code> or the result of expression + <code class="computeroutput"><span class="identifier">lhs</span><span class="special"><<=</span><span class="identifier">rhs</span></code> is convertible to <code class="computeroutput"><span class="identifier">Ret</span></code> + then inherits from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>, + otherwise inherits from <a class="link" href="integral_constant.html" title="integral_constant">false_type</a>. + </p> +<p> + The default behaviour (<code class="computeroutput"><span class="identifier">Ret</span><span class="special">=</span><span class="identifier">dont_care</span></code>) + is to not check for the return value of binary <code class="computeroutput"><span class="keyword">operator</span><span class="special"><<=</span></code>. If <code class="computeroutput"><span class="identifier">Ret</span></code> + is different from the default <code class="computeroutput"><span class="identifier">dont_care</span></code> + type, the return value is checked to be convertible to <code class="computeroutput"><span class="identifier">Ret</span></code>. + Convertible to <code class="computeroutput"><span class="identifier">Ret</span></code> means + that the return value of the operator can be used as argument to a function + expecting <code class="computeroutput"><span class="identifier">Ret</span></code>: +</p> +<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">Ret</span><span class="special">);</span> +<span class="identifier">Lhs</span> <span class="identifier">lhs</span><span class="special">;</span> +<span class="identifier">Rhs</span> <span class="identifier">rhs</span><span class="special">;</span> +<span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special"><<=</span><span class="identifier">rhs</span><span class="special">);</span> <span class="comment">// is valid if has_left_shift_assign<Lhs, Rhs, Ret>::value==true</span> +</pre> +<p> + If <code class="computeroutput"><span class="identifier">Ret</span><span class="special">=</span><span class="keyword">void</span></code>, the return type is checked to be exactly + <code class="computeroutput"><span class="keyword">void</span></code>. + </p> +<p> + <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"><span class="preprocessor">#include</span> + <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_left_shift_assign</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_operator</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + </p> +<p> + <span class="bold"><strong>Examples:</strong></span> + </p> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_left_shift_assign</span><span class="special"><</span><span class="identifier">Lhs</span><span class="special">,</span> <span class="identifier">Rhs</span><span class="special">,</span> <span class="identifier">Ret</span><span class="special">>::</span><span class="identifier">value_type</span></code> is the type <code class="computeroutput"><span class="keyword">bool</span></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_left_shift_assign</span><span class="special"><</span><span class="identifier">Lhs</span><span class="special">,</span> <span class="identifier">Rhs</span><span class="special">,</span> <span class="identifier">Ret</span><span class="special">>::</span><span class="identifier">value</span></code> is a <code class="computeroutput"><span class="keyword">bool</span></code> + integral constant expression. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_left_shift_assign</span><span class="special"><</span><span class="keyword">int</span><span class="special">>::</span><span class="identifier">value</span></code> is a <code class="computeroutput"><span class="keyword">bool</span></code> + integral constant expression that evaluates to <code class="computeroutput"><span class="keyword">true</span></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_left_shift_assign</span><span class="special"><</span><span class="keyword">long</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_left_shift_assign</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_left_shift_assign</span><span class="special"><</span><span class="keyword">const</span> <span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_left_shift_assign</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">bool</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_left_shift_assign</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>. + </p></blockquote></div> +<p> + <span class="bold"><strong>See also:</strong></span> <a class="link" href="../category/value_traits/operators.html" title="Operator Type Traits">Operator + Type Traits</a> + </p> +<p> + <span class="bold"><strong>Limitation:</strong></span> + </p> +<div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"> + Requires a compiler with working SFINAE. + </li></ul></div> +<p> + <span class="bold"><strong>Known issues:</strong></span> + </p> +<div class="itemizedlist"><ul class="itemizedlist" type="disc"> +<li class="listitem"> + This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special"><<=</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special"><<=</span></code> + is defined as a private member of <code class="computeroutput"><span class="identifier">Lhs</span></code> + then instantiating <code class="computeroutput"><span class="identifier">has_left_shift_assign</span><span class="special"><</span><span class="identifier">Lhs</span><span class="special">></span></code> will produce a compiler error. For + this reason <code class="computeroutput"><span class="identifier">has_left_shift_assign</span></code> + cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special"><<=</span></code> + or not. +<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special"><<=(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&);</span> <span class="special">};</span> +<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_left_shift_assign</span><span class="special"><</span><span class="identifier">A</span><span class="special">>::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator<<=(const A&) is private</span> +</pre> + </li> +<li class="listitem"> + There is an issue if the operator exists only for type <code class="computeroutput"><span class="identifier">A</span></code> and <code class="computeroutput"><span class="identifier">B</span></code> + is convertible to <code class="computeroutput"><span class="identifier">A</span></code>. + In this case, the compiler will report an ambiguous overload. +<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span> +<span class="keyword">void</span> <span class="keyword">operator</span><span class="special"><<=(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&,</span> <span class="keyword">const</span> <span class="identifier">A</span><span class="special">&);</span> +<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span> +<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_left_shift_assign</span><span class="special"><</span><span class="identifier">A</span><span class="special">>::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine</span> +<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_left_shift_assign</span><span class="special"><</span><span class="identifier">B</span><span class="special">>::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambiguous overload</span> +</pre> + </li> +<li class="listitem"> + There is an issue when applying this trait to template classes. If <code class="computeroutput"><span class="keyword">operator</span><span class="special"><<=</span></code> + is defined but does not bind for a given template type, it is still detected + by the trait which returns <code class="computeroutput"><span class="keyword">true</span></code> + instead of <code class="computeroutput"><span class="keyword">false</span></code>. Example: + +<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_left_shift_assign</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span> +<span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">iostream</span><span class="special">></span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">contains</span> <span class="special">{</span> <span class="identifier">T</span> <span class="identifier">data</span><span class="special">;</span> <span class="special">};</span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">bool</span> <span class="keyword">operator</span><span class="special"><<=(</span><span class="keyword">const</span> <span class="identifier">contains</span><span class="special"><</span><span class="identifier">T</span><span class="special">></span> <span class="special">&</span><span class="identifier">lhs</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">contains</span><span class="special"><</span><span class="identifier">T</span><span class="special">></span> <span class="special">&</span><span class="identifier">rhs</span><span class="special">)</span> <span class="special">{</span> + <span class="keyword">return</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">,</span> <span class="identifier">rhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">);</span> +<span class="special">}</span> + +<span class="keyword">class</span> <span class="identifier">bad</span> <span class="special">{</span> <span class="special">};</span> +<span class="keyword">class</span> <span class="identifier">good</span> <span class="special">{</span> <span class="special">};</span> +<span class="keyword">bool</span> <span class="identifier">f</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">good</span><span class="special">&,</span> <span class="keyword">const</span> <span class="identifier">good</span><span class="special">&)</span> <span class="special">{</span> <span class="special">}</span> + +<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span> <span class="special">{</span> + <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special"><<</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">boolalpha</span><span class="special">;</span> + <span class="comment">// works fine for contains<good></span> + <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special"><<</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_left_shift_assign</span><span class="special"><</span> <span class="identifier">contains</span><span class="special"><</span> <span class="identifier">good</span> <span class="special">></span> <span class="special">>::</span><span class="identifier">value</span><span class="special"><<</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true</span> + <span class="identifier">contains</span><span class="special"><</span><span class="identifier">good</span><span class="special">></span> <span class="identifier">g</span><span class="special">;</span> + <span class="identifier">g</span><span class="special"><<=</span><span class="identifier">g</span><span class="special">;</span> <span class="comment">// ok</span> + <span class="comment">// does not work for contains<bad></span> + <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special"><<</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_left_shift_assign</span><span class="special"><</span> <span class="identifier">contains</span><span class="special"><</span> <span class="identifier">bad</span> <span class="special">></span> <span class="special">>::</span><span class="identifier">value</span><span class="special"><<</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true, should be false</span> + <span class="identifier">contains</span><span class="special"><</span><span class="identifier">bad</span><span class="special">></span> <span class="identifier">b</span><span class="special">;</span> + <span class="identifier">b</span><span class="special"><<=</span><span class="identifier">b</span><span class="special">;</span> <span class="comment">// compile time error</span> + <span class="keyword">return</span> <span class="number">0</span><span class="special">;</span> +<span class="special">}</span> +</pre> + </li> +<li class="listitem"> + <code class="computeroutput"><span class="keyword">volatile</span></code> qualifier is not + properly handled and would lead to undefined behavior + </li> +</ul></div> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="has_left_shift.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="has_less.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/reference/has_less.html b/libs/type_traits/doc/html/boost_typetraits/reference/has_less.html new file mode 100644 index 0000000000..5e74681819 --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/reference/has_less.html @@ -0,0 +1,197 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>has_less</title> +<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../reference.html" title="Alphabetical Reference"> +<link rel="prev" href="has_left_shift_assign.html" title="has_left_shift_assign"> +<link rel="next" href="has_less_equal.html" title="has_less_equal"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td> +<td align="center"><a href="../../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="has_left_shift_assign.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="has_less_equal.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h3 class="title"> +<a name="boost_typetraits.reference.has_less"></a><a class="link" href="has_less.html" title="has_less">has_less</a> +</h3></div></div></div> +<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">Lhs</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Rhs</span><span class="special">=</span><span class="identifier">Lhs</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Ret</span><span class="special">=</span><span class="identifier">dont_care</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">has_less</span> <span class="special">:</span> <span class="keyword">public</span> <em class="replaceable"><code><a class="link" href="integral_constant.html" title="integral_constant">true_type</a>-or-<a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code></em> <span class="special">{};</span> +</pre> +<p> + <span class="bold"><strong>Inherits:</strong></span> If (i) <code class="computeroutput"><span class="identifier">lhs</span></code> + of type <code class="computeroutput"><span class="identifier">Lhs</span></code> and <code class="computeroutput"><span class="identifier">rhs</span></code> of type <code class="computeroutput"><span class="identifier">Rhs</span></code> + can be used in expression <code class="computeroutput"><span class="identifier">lhs</span><span class="special"><</span><span class="identifier">rhs</span></code>, + and (ii) <code class="computeroutput"><span class="identifier">Ret</span><span class="special">=</span><span class="identifier">dont_care</span></code> or the result of expression + <code class="computeroutput"><span class="identifier">lhs</span><span class="special"><</span><span class="identifier">rhs</span></code> is convertible to <code class="computeroutput"><span class="identifier">Ret</span></code> + then inherits from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>, + otherwise inherits from <a class="link" href="integral_constant.html" title="integral_constant">false_type</a>. + </p> +<p> + The default behaviour (<code class="computeroutput"><span class="identifier">Ret</span><span class="special">=</span><span class="identifier">dont_care</span></code>) + is to not check for the return value of binary <code class="computeroutput"><span class="keyword">operator</span><span class="special"><</span></code>. If <code class="computeroutput"><span class="identifier">Ret</span></code> + is different from the default <code class="computeroutput"><span class="identifier">dont_care</span></code> + type, the return value is checked to be convertible to <code class="computeroutput"><span class="identifier">Ret</span></code>. + Convertible to <code class="computeroutput"><span class="identifier">Ret</span></code> means + that the return value of the operator can be used as argument to a function + expecting <code class="computeroutput"><span class="identifier">Ret</span></code>: +</p> +<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">Ret</span><span class="special">);</span> +<span class="identifier">Lhs</span> <span class="identifier">lhs</span><span class="special">;</span> +<span class="identifier">Rhs</span> <span class="identifier">rhs</span><span class="special">;</span> +<span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special"><</span><span class="identifier">rhs</span><span class="special">);</span> <span class="comment">// is valid if has_less<Lhs, Rhs, Ret>::value==true</span> +</pre> +<p> + If <code class="computeroutput"><span class="identifier">Ret</span><span class="special">=</span><span class="keyword">void</span></code>, the return type is checked to be exactly + <code class="computeroutput"><span class="keyword">void</span></code>. + </p> +<p> + <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"><span class="preprocessor">#include</span> + <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_less</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_operator</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + </p> +<p> + <span class="bold"><strong>Examples:</strong></span> + </p> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_less</span><span class="special"><</span><span class="identifier">Lhs</span><span class="special">,</span> <span class="identifier">Rhs</span><span class="special">,</span> <span class="identifier">Ret</span><span class="special">>::</span><span class="identifier">value_type</span></code> is the type <code class="computeroutput"><span class="keyword">bool</span></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_less</span><span class="special"><</span><span class="identifier">Lhs</span><span class="special">,</span> <span class="identifier">Rhs</span><span class="special">,</span> <span class="identifier">Ret</span><span class="special">>::</span><span class="identifier">value</span></code> is a <code class="computeroutput"><span class="keyword">bool</span></code> + integral constant expression. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_less</span><span class="special"><</span><span class="keyword">int</span><span class="special">>::</span><span class="identifier">value</span></code> is a <code class="computeroutput"><span class="keyword">bool</span></code> + integral constant expression that evaluates to <code class="computeroutput"><span class="keyword">true</span></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_less</span><span class="special"><</span><span class="keyword">long</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_less</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="keyword">bool</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_less</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">bool</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_less</span><span class="special"><</span><span class="keyword">const</span> <span class="keyword">int</span><span class="special">></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_less</span><span class="special"><</span><span class="keyword">int</span><span class="special">*,</span> <span class="keyword">int</span><span class="special">></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_less</span><span class="special"><</span><span class="keyword">int</span><span class="special">*,</span> <span class="keyword">double</span><span class="special">*></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_less</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>. + </p></blockquote></div> +<p> + <span class="bold"><strong>See also:</strong></span> <a class="link" href="../category/value_traits/operators.html" title="Operator Type Traits">Operator + Type Traits</a> + </p> +<p> + <span class="bold"><strong>Limitation:</strong></span> + </p> +<div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"> + Requires a compiler with working SFINAE. + </li></ul></div> +<p> + <span class="bold"><strong>Known issues:</strong></span> + </p> +<div class="itemizedlist"><ul class="itemizedlist" type="disc"> +<li class="listitem"> + This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special"><</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special"><</span></code> + is defined as a private member of <code class="computeroutput"><span class="identifier">Lhs</span></code> + then instantiating <code class="computeroutput"><span class="identifier">has_less</span><span class="special"><</span><span class="identifier">Lhs</span><span class="special">></span></code> will produce a compiler error. For + this reason <code class="computeroutput"><span class="identifier">has_less</span></code> + cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special"><</span></code> + or not. +<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special"><(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&);</span> <span class="special">};</span> +<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_less</span><span class="special"><</span><span class="identifier">A</span><span class="special">>::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator<(const A&) is private</span> +</pre> + </li> +<li class="listitem"> + There is an issue if the operator exists only for type <code class="computeroutput"><span class="identifier">A</span></code> and <code class="computeroutput"><span class="identifier">B</span></code> + is convertible to <code class="computeroutput"><span class="identifier">A</span></code>. + In this case, the compiler will report an ambiguous overload. +<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span> +<span class="keyword">void</span> <span class="keyword">operator</span><span class="special"><(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&,</span> <span class="keyword">const</span> <span class="identifier">A</span><span class="special">&);</span> +<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span> +<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_less</span><span class="special"><</span><span class="identifier">A</span><span class="special">>::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine</span> +<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_less</span><span class="special"><</span><span class="identifier">B</span><span class="special">>::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambiguous overload</span> +</pre> + </li> +<li class="listitem"> + There is an issue when applying this trait to template classes. If <code class="computeroutput"><span class="keyword">operator</span><span class="special"><</span></code> + is defined but does not bind for a given template type, it is still detected + by the trait which returns <code class="computeroutput"><span class="keyword">true</span></code> + instead of <code class="computeroutput"><span class="keyword">false</span></code>. Example: + +<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_less</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span> +<span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">iostream</span><span class="special">></span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">contains</span> <span class="special">{</span> <span class="identifier">T</span> <span class="identifier">data</span><span class="special">;</span> <span class="special">};</span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">bool</span> <span class="keyword">operator</span><span class="special"><(</span><span class="keyword">const</span> <span class="identifier">contains</span><span class="special"><</span><span class="identifier">T</span><span class="special">></span> <span class="special">&</span><span class="identifier">lhs</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">contains</span><span class="special"><</span><span class="identifier">T</span><span class="special">></span> <span class="special">&</span><span class="identifier">rhs</span><span class="special">)</span> <span class="special">{</span> + <span class="keyword">return</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">,</span> <span class="identifier">rhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">);</span> +<span class="special">}</span> + +<span class="keyword">class</span> <span class="identifier">bad</span> <span class="special">{</span> <span class="special">};</span> +<span class="keyword">class</span> <span class="identifier">good</span> <span class="special">{</span> <span class="special">};</span> +<span class="keyword">bool</span> <span class="identifier">f</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">good</span><span class="special">&,</span> <span class="keyword">const</span> <span class="identifier">good</span><span class="special">&)</span> <span class="special">{</span> <span class="special">}</span> + +<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span> <span class="special">{</span> + <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special"><<</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">boolalpha</span><span class="special">;</span> + <span class="comment">// works fine for contains<good></span> + <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special"><<</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_less</span><span class="special"><</span> <span class="identifier">contains</span><span class="special"><</span> <span class="identifier">good</span> <span class="special">></span> <span class="special">>::</span><span class="identifier">value</span><span class="special"><<</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true</span> + <span class="identifier">contains</span><span class="special"><</span><span class="identifier">good</span><span class="special">></span> <span class="identifier">g</span><span class="special">;</span> + <span class="identifier">g</span><span class="special"><</span><span class="identifier">g</span><span class="special">;</span> <span class="comment">// ok</span> + <span class="comment">// does not work for contains<bad></span> + <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special"><<</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_less</span><span class="special"><</span> <span class="identifier">contains</span><span class="special"><</span> <span class="identifier">bad</span> <span class="special">></span> <span class="special">>::</span><span class="identifier">value</span><span class="special"><<</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true, should be false</span> + <span class="identifier">contains</span><span class="special"><</span><span class="identifier">bad</span><span class="special">></span> <span class="identifier">b</span><span class="special">;</span> + <span class="identifier">b</span><span class="special"><</span><span class="identifier">b</span><span class="special">;</span> <span class="comment">// compile time error</span> + <span class="keyword">return</span> <span class="number">0</span><span class="special">;</span> +<span class="special">}</span> +</pre> + </li> +<li class="listitem"> + <code class="computeroutput"><span class="keyword">volatile</span></code> qualifier is not + properly handled and would lead to undefined behavior + </li> +</ul></div> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="has_left_shift_assign.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="has_less_equal.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/reference/has_less_equal.html b/libs/type_traits/doc/html/boost_typetraits/reference/has_less_equal.html new file mode 100644 index 0000000000..d442813cce --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/reference/has_less_equal.html @@ -0,0 +1,197 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>has_less_equal</title> +<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../reference.html" title="Alphabetical Reference"> +<link rel="prev" href="has_less.html" title="has_less"> +<link rel="next" href="has_logical_and.html" title="has_logical_and"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td> +<td align="center"><a href="../../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="has_less.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="has_logical_and.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h3 class="title"> +<a name="boost_typetraits.reference.has_less_equal"></a><a class="link" href="has_less_equal.html" title="has_less_equal">has_less_equal</a> +</h3></div></div></div> +<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">Lhs</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Rhs</span><span class="special">=</span><span class="identifier">Lhs</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Ret</span><span class="special">=</span><span class="identifier">dont_care</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">has_less_equal</span> <span class="special">:</span> <span class="keyword">public</span> <em class="replaceable"><code><a class="link" href="integral_constant.html" title="integral_constant">true_type</a>-or-<a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code></em> <span class="special">{};</span> +</pre> +<p> + <span class="bold"><strong>Inherits:</strong></span> If (i) <code class="computeroutput"><span class="identifier">lhs</span></code> + of type <code class="computeroutput"><span class="identifier">Lhs</span></code> and <code class="computeroutput"><span class="identifier">rhs</span></code> of type <code class="computeroutput"><span class="identifier">Rhs</span></code> + can be used in expression <code class="computeroutput"><span class="identifier">lhs</span><span class="special"><=</span><span class="identifier">rhs</span></code>, + and (ii) <code class="computeroutput"><span class="identifier">Ret</span><span class="special">=</span><span class="identifier">dont_care</span></code> or the result of expression + <code class="computeroutput"><span class="identifier">lhs</span><span class="special"><=</span><span class="identifier">rhs</span></code> is convertible to <code class="computeroutput"><span class="identifier">Ret</span></code> + then inherits from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>, + otherwise inherits from <a class="link" href="integral_constant.html" title="integral_constant">false_type</a>. + </p> +<p> + The default behaviour (<code class="computeroutput"><span class="identifier">Ret</span><span class="special">=</span><span class="identifier">dont_care</span></code>) + is to not check for the return value of binary <code class="computeroutput"><span class="keyword">operator</span><span class="special"><=</span></code>. If <code class="computeroutput"><span class="identifier">Ret</span></code> + is different from the default <code class="computeroutput"><span class="identifier">dont_care</span></code> + type, the return value is checked to be convertible to <code class="computeroutput"><span class="identifier">Ret</span></code>. + Convertible to <code class="computeroutput"><span class="identifier">Ret</span></code> means + that the return value of the operator can be used as argument to a function + expecting <code class="computeroutput"><span class="identifier">Ret</span></code>: +</p> +<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">Ret</span><span class="special">);</span> +<span class="identifier">Lhs</span> <span class="identifier">lhs</span><span class="special">;</span> +<span class="identifier">Rhs</span> <span class="identifier">rhs</span><span class="special">;</span> +<span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special"><=</span><span class="identifier">rhs</span><span class="special">);</span> <span class="comment">// is valid if has_less_equal<Lhs, Rhs, Ret>::value==true</span> +</pre> +<p> + If <code class="computeroutput"><span class="identifier">Ret</span><span class="special">=</span><span class="keyword">void</span></code>, the return type is checked to be exactly + <code class="computeroutput"><span class="keyword">void</span></code>. + </p> +<p> + <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"><span class="preprocessor">#include</span> + <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_less_equal</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_operator</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + </p> +<p> + <span class="bold"><strong>Examples:</strong></span> + </p> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_less_equal</span><span class="special"><</span><span class="identifier">Lhs</span><span class="special">,</span> <span class="identifier">Rhs</span><span class="special">,</span> <span class="identifier">Ret</span><span class="special">>::</span><span class="identifier">value_type</span></code> is the type <code class="computeroutput"><span class="keyword">bool</span></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_less_equal</span><span class="special"><</span><span class="identifier">Lhs</span><span class="special">,</span> <span class="identifier">Rhs</span><span class="special">,</span> <span class="identifier">Ret</span><span class="special">>::</span><span class="identifier">value</span></code> is a <code class="computeroutput"><span class="keyword">bool</span></code> + integral constant expression. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_less_equal</span><span class="special"><</span><span class="keyword">int</span><span class="special">>::</span><span class="identifier">value</span></code> is a <code class="computeroutput"><span class="keyword">bool</span></code> + integral constant expression that evaluates to <code class="computeroutput"><span class="keyword">true</span></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_less_equal</span><span class="special"><</span><span class="keyword">long</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_less_equal</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="keyword">bool</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_less_equal</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">bool</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_less_equal</span><span class="special"><</span><span class="keyword">const</span> <span class="keyword">int</span><span class="special">></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_less_equal</span><span class="special"><</span><span class="keyword">int</span><span class="special">*,</span> <span class="keyword">int</span><span class="special">></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_less_equal</span><span class="special"><</span><span class="keyword">int</span><span class="special">*,</span> <span class="keyword">double</span><span class="special">*></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_less_equal</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>. + </p></blockquote></div> +<p> + <span class="bold"><strong>See also:</strong></span> <a class="link" href="../category/value_traits/operators.html" title="Operator Type Traits">Operator + Type Traits</a> + </p> +<p> + <span class="bold"><strong>Limitation:</strong></span> + </p> +<div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"> + Requires a compiler with working SFINAE. + </li></ul></div> +<p> + <span class="bold"><strong>Known issues:</strong></span> + </p> +<div class="itemizedlist"><ul class="itemizedlist" type="disc"> +<li class="listitem"> + This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special"><=</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special"><=</span></code> + is defined as a private member of <code class="computeroutput"><span class="identifier">Lhs</span></code> + then instantiating <code class="computeroutput"><span class="identifier">has_less_equal</span><span class="special"><</span><span class="identifier">Lhs</span><span class="special">></span></code> will produce a compiler error. For + this reason <code class="computeroutput"><span class="identifier">has_less_equal</span></code> + cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special"><=</span></code> + or not. +<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special"><=(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&);</span> <span class="special">};</span> +<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_less_equal</span><span class="special"><</span><span class="identifier">A</span><span class="special">>::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator<=(const A&) is private</span> +</pre> + </li> +<li class="listitem"> + There is an issue if the operator exists only for type <code class="computeroutput"><span class="identifier">A</span></code> and <code class="computeroutput"><span class="identifier">B</span></code> + is convertible to <code class="computeroutput"><span class="identifier">A</span></code>. + In this case, the compiler will report an ambiguous overload. +<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span> +<span class="keyword">void</span> <span class="keyword">operator</span><span class="special"><=(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&,</span> <span class="keyword">const</span> <span class="identifier">A</span><span class="special">&);</span> +<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span> +<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_less_equal</span><span class="special"><</span><span class="identifier">A</span><span class="special">>::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine</span> +<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_less_equal</span><span class="special"><</span><span class="identifier">B</span><span class="special">>::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambiguous overload</span> +</pre> + </li> +<li class="listitem"> + There is an issue when applying this trait to template classes. If <code class="computeroutput"><span class="keyword">operator</span><span class="special"><=</span></code> + is defined but does not bind for a given template type, it is still detected + by the trait which returns <code class="computeroutput"><span class="keyword">true</span></code> + instead of <code class="computeroutput"><span class="keyword">false</span></code>. Example: + +<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_less_equal</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span> +<span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">iostream</span><span class="special">></span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">contains</span> <span class="special">{</span> <span class="identifier">T</span> <span class="identifier">data</span><span class="special">;</span> <span class="special">};</span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">bool</span> <span class="keyword">operator</span><span class="special"><=(</span><span class="keyword">const</span> <span class="identifier">contains</span><span class="special"><</span><span class="identifier">T</span><span class="special">></span> <span class="special">&</span><span class="identifier">lhs</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">contains</span><span class="special"><</span><span class="identifier">T</span><span class="special">></span> <span class="special">&</span><span class="identifier">rhs</span><span class="special">)</span> <span class="special">{</span> + <span class="keyword">return</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">,</span> <span class="identifier">rhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">);</span> +<span class="special">}</span> + +<span class="keyword">class</span> <span class="identifier">bad</span> <span class="special">{</span> <span class="special">};</span> +<span class="keyword">class</span> <span class="identifier">good</span> <span class="special">{</span> <span class="special">};</span> +<span class="keyword">bool</span> <span class="identifier">f</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">good</span><span class="special">&,</span> <span class="keyword">const</span> <span class="identifier">good</span><span class="special">&)</span> <span class="special">{</span> <span class="special">}</span> + +<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span> <span class="special">{</span> + <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special"><<</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">boolalpha</span><span class="special">;</span> + <span class="comment">// works fine for contains<good></span> + <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special"><<</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_less_equal</span><span class="special"><</span> <span class="identifier">contains</span><span class="special"><</span> <span class="identifier">good</span> <span class="special">></span> <span class="special">>::</span><span class="identifier">value</span><span class="special"><<</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true</span> + <span class="identifier">contains</span><span class="special"><</span><span class="identifier">good</span><span class="special">></span> <span class="identifier">g</span><span class="special">;</span> + <span class="identifier">g</span><span class="special"><=</span><span class="identifier">g</span><span class="special">;</span> <span class="comment">// ok</span> + <span class="comment">// does not work for contains<bad></span> + <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special"><<</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_less_equal</span><span class="special"><</span> <span class="identifier">contains</span><span class="special"><</span> <span class="identifier">bad</span> <span class="special">></span> <span class="special">>::</span><span class="identifier">value</span><span class="special"><<</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true, should be false</span> + <span class="identifier">contains</span><span class="special"><</span><span class="identifier">bad</span><span class="special">></span> <span class="identifier">b</span><span class="special">;</span> + <span class="identifier">b</span><span class="special"><=</span><span class="identifier">b</span><span class="special">;</span> <span class="comment">// compile time error</span> + <span class="keyword">return</span> <span class="number">0</span><span class="special">;</span> +<span class="special">}</span> +</pre> + </li> +<li class="listitem"> + <code class="computeroutput"><span class="keyword">volatile</span></code> qualifier is not + properly handled and would lead to undefined behavior + </li> +</ul></div> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="has_less.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="has_logical_and.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/reference/has_logical_and.html b/libs/type_traits/doc/html/boost_typetraits/reference/has_logical_and.html new file mode 100644 index 0000000000..eeceffdc3b --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/reference/has_logical_and.html @@ -0,0 +1,195 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>has_logical_and</title> +<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../reference.html" title="Alphabetical Reference"> +<link rel="prev" href="has_less_equal.html" title="has_less_equal"> +<link rel="next" href="has_logical_not.html" title="has_logical_not"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td> +<td align="center"><a href="../../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="has_less_equal.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="has_logical_not.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h3 class="title"> +<a name="boost_typetraits.reference.has_logical_and"></a><a class="link" href="has_logical_and.html" title="has_logical_and">has_logical_and</a> +</h3></div></div></div> +<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">Lhs</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Rhs</span><span class="special">=</span><span class="identifier">Lhs</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Ret</span><span class="special">=</span><span class="identifier">dont_care</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">has_logical_and</span> <span class="special">:</span> <span class="keyword">public</span> <em class="replaceable"><code><a class="link" href="integral_constant.html" title="integral_constant">true_type</a>-or-<a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code></em> <span class="special">{};</span> +</pre> +<p> + <span class="bold"><strong>Inherits:</strong></span> If (i) <code class="computeroutput"><span class="identifier">lhs</span></code> + of type <code class="computeroutput"><span class="identifier">Lhs</span></code> and <code class="computeroutput"><span class="identifier">rhs</span></code> of type <code class="computeroutput"><span class="identifier">Rhs</span></code> + can be used in expression <code class="computeroutput"><span class="identifier">lhs</span><span class="special">&&</span><span class="identifier">rhs</span></code>, + and (ii) <code class="computeroutput"><span class="identifier">Ret</span><span class="special">=</span><span class="identifier">dont_care</span></code> or the result of expression + <code class="computeroutput"><span class="identifier">lhs</span><span class="special">&&</span><span class="identifier">rhs</span></code> is convertible to <code class="computeroutput"><span class="identifier">Ret</span></code> + then inherits from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>, + otherwise inherits from <a class="link" href="integral_constant.html" title="integral_constant">false_type</a>. + </p> +<p> + The default behaviour (<code class="computeroutput"><span class="identifier">Ret</span><span class="special">=</span><span class="identifier">dont_care</span></code>) + is to not check for the return value of binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">&&</span></code>. If <code class="computeroutput"><span class="identifier">Ret</span></code> + is different from the default <code class="computeroutput"><span class="identifier">dont_care</span></code> + type, the return value is checked to be convertible to <code class="computeroutput"><span class="identifier">Ret</span></code>. + Convertible to <code class="computeroutput"><span class="identifier">Ret</span></code> means + that the return value of the operator can be used as argument to a function + expecting <code class="computeroutput"><span class="identifier">Ret</span></code>: +</p> +<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">Ret</span><span class="special">);</span> +<span class="identifier">Lhs</span> <span class="identifier">lhs</span><span class="special">;</span> +<span class="identifier">Rhs</span> <span class="identifier">rhs</span><span class="special">;</span> +<span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">&&</span><span class="identifier">rhs</span><span class="special">);</span> <span class="comment">// is valid if has_logical_and<Lhs, Rhs, Ret>::value==true</span> +</pre> +<p> + If <code class="computeroutput"><span class="identifier">Ret</span><span class="special">=</span><span class="keyword">void</span></code>, the return type is checked to be exactly + <code class="computeroutput"><span class="keyword">void</span></code>. + </p> +<p> + <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"><span class="preprocessor">#include</span> + <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_logical_and</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_operator</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + </p> +<p> + <span class="bold"><strong>Examples:</strong></span> + </p> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_logical_and</span><span class="special"><</span><span class="identifier">Lhs</span><span class="special">,</span> <span class="identifier">Rhs</span><span class="special">,</span> <span class="identifier">Ret</span><span class="special">>::</span><span class="identifier">value_type</span></code> is the type <code class="computeroutput"><span class="keyword">bool</span></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_logical_and</span><span class="special"><</span><span class="identifier">Lhs</span><span class="special">,</span> <span class="identifier">Rhs</span><span class="special">,</span> <span class="identifier">Ret</span><span class="special">>::</span><span class="identifier">value</span></code> is a <code class="computeroutput"><span class="keyword">bool</span></code> + integral constant expression. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_logical_and</span><span class="special"><</span><span class="keyword">int</span><span class="special">>::</span><span class="identifier">value</span></code> is a <code class="computeroutput"><span class="keyword">bool</span></code> + integral constant expression that evaluates to <code class="computeroutput"><span class="keyword">true</span></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_logical_and</span><span class="special"><</span><span class="keyword">bool</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_logical_and</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="keyword">bool</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_logical_and</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="keyword">long</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_logical_and</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">bool</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_logical_and</span><span class="special"><</span><span class="keyword">const</span> <span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">>::</span><span class="identifier">value</span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_logical_and</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>. + </p></blockquote></div> +<p> + <span class="bold"><strong>See also:</strong></span> <a class="link" href="../category/value_traits/operators.html" title="Operator Type Traits">Operator + Type Traits</a> + </p> +<p> + <span class="bold"><strong>Limitation:</strong></span> + </p> +<div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"> + Requires a compiler with working SFINAE. + </li></ul></div> +<p> + <span class="bold"><strong>Known issues:</strong></span> + </p> +<div class="itemizedlist"><ul class="itemizedlist" type="disc"> +<li class="listitem"> + This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">&&</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">&&</span></code> + is defined as a private member of <code class="computeroutput"><span class="identifier">Lhs</span></code> + then instantiating <code class="computeroutput"><span class="identifier">has_logical_and</span><span class="special"><</span><span class="identifier">Lhs</span><span class="special">></span></code> will produce a compiler error. For + this reason <code class="computeroutput"><span class="identifier">has_logical_and</span></code> + cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">&&</span></code> + or not. +<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">&&(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&);</span> <span class="special">};</span> +<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_logical_and</span><span class="special"><</span><span class="identifier">A</span><span class="special">>::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator&&(const A&) is private</span> +</pre> + </li> +<li class="listitem"> + There is an issue if the operator exists only for type <code class="computeroutput"><span class="identifier">A</span></code> and <code class="computeroutput"><span class="identifier">B</span></code> + is convertible to <code class="computeroutput"><span class="identifier">A</span></code>. + In this case, the compiler will report an ambiguous overload. +<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span> +<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">&&(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&,</span> <span class="keyword">const</span> <span class="identifier">A</span><span class="special">&);</span> +<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span> +<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_logical_and</span><span class="special"><</span><span class="identifier">A</span><span class="special">>::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine</span> +<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_logical_and</span><span class="special"><</span><span class="identifier">B</span><span class="special">>::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambiguous overload</span> +</pre> + </li> +<li class="listitem"> + There is an issue when applying this trait to template classes. If <code class="computeroutput"><span class="keyword">operator</span><span class="special">&&</span></code> + is defined but does not bind for a given template type, it is still detected + by the trait which returns <code class="computeroutput"><span class="keyword">true</span></code> + instead of <code class="computeroutput"><span class="keyword">false</span></code>. Example: + +<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_logical_and</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span> +<span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">iostream</span><span class="special">></span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">contains</span> <span class="special">{</span> <span class="identifier">T</span> <span class="identifier">data</span><span class="special">;</span> <span class="special">};</span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">&&(</span><span class="keyword">const</span> <span class="identifier">contains</span><span class="special"><</span><span class="identifier">T</span><span class="special">></span> <span class="special">&</span><span class="identifier">lhs</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">contains</span><span class="special"><</span><span class="identifier">T</span><span class="special">></span> <span class="special">&</span><span class="identifier">rhs</span><span class="special">)</span> <span class="special">{</span> + <span class="keyword">return</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">,</span> <span class="identifier">rhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">);</span> +<span class="special">}</span> + +<span class="keyword">class</span> <span class="identifier">bad</span> <span class="special">{</span> <span class="special">};</span> +<span class="keyword">class</span> <span class="identifier">good</span> <span class="special">{</span> <span class="special">};</span> +<span class="keyword">bool</span> <span class="identifier">f</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">good</span><span class="special">&,</span> <span class="keyword">const</span> <span class="identifier">good</span><span class="special">&)</span> <span class="special">{</span> <span class="special">}</span> + +<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span> <span class="special">{</span> + <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special"><<</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">boolalpha</span><span class="special">;</span> + <span class="comment">// works fine for contains<good></span> + <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special"><<</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_logical_and</span><span class="special"><</span> <span class="identifier">contains</span><span class="special"><</span> <span class="identifier">good</span> <span class="special">></span> <span class="special">>::</span><span class="identifier">value</span><span class="special"><<</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true</span> + <span class="identifier">contains</span><span class="special"><</span><span class="identifier">good</span><span class="special">></span> <span class="identifier">g</span><span class="special">;</span> + <span class="identifier">g</span><span class="special">&&</span><span class="identifier">g</span><span class="special">;</span> <span class="comment">// ok</span> + <span class="comment">// does not work for contains<bad></span> + <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special"><<</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_logical_and</span><span class="special"><</span> <span class="identifier">contains</span><span class="special"><</span> <span class="identifier">bad</span> <span class="special">></span> <span class="special">>::</span><span class="identifier">value</span><span class="special"><<</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true, should be false</span> + <span class="identifier">contains</span><span class="special"><</span><span class="identifier">bad</span><span class="special">></span> <span class="identifier">b</span><span class="special">;</span> + <span class="identifier">b</span><span class="special">&&</span><span class="identifier">b</span><span class="special">;</span> <span class="comment">// compile time error</span> + <span class="keyword">return</span> <span class="number">0</span><span class="special">;</span> +<span class="special">}</span> +</pre> + </li> +<li class="listitem"> + <code class="computeroutput"><span class="keyword">volatile</span></code> qualifier is not + properly handled and would lead to undefined behavior + </li> +</ul></div> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="has_less_equal.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="has_logical_not.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/reference/has_logical_not.html b/libs/type_traits/doc/html/boost_typetraits/reference/has_logical_not.html new file mode 100644 index 0000000000..99a65baffa --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/reference/has_logical_not.html @@ -0,0 +1,195 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>has_logical_not</title> +<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../reference.html" title="Alphabetical Reference"> +<link rel="prev" href="has_logical_and.html" title="has_logical_and"> +<link rel="next" href="has_logical_or.html" title="has_logical_or"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td> +<td align="center"><a href="../../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="has_logical_and.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="has_logical_or.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h3 class="title"> +<a name="boost_typetraits.reference.has_logical_not"></a><a class="link" href="has_logical_not.html" title="has_logical_not">has_logical_not</a> +</h3></div></div></div> +<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">Rhs</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Ret</span><span class="special">=</span><span class="identifier">dont_care</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">has_logical_not</span> <span class="special">:</span> <span class="keyword">public</span> <em class="replaceable"><code><a class="link" href="integral_constant.html" title="integral_constant">true_type</a>-or-<a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code></em> <span class="special">{};</span> +</pre> +<p> + <span class="bold"><strong>Inherits:</strong></span> If (i) <code class="computeroutput"><span class="identifier">rhs</span></code> + of type <code class="computeroutput"><span class="identifier">Rhs</span></code> can be used in + expression <code class="computeroutput"><span class="special">!</span><span class="identifier">rhs</span></code>, + and (ii) <code class="computeroutput"><span class="identifier">Ret</span><span class="special">=</span><span class="identifier">dont_care</span></code> or the result of expression + <code class="computeroutput"><span class="special">!</span><span class="identifier">rhs</span></code> + is convertible to <code class="computeroutput"><span class="identifier">Ret</span></code> then + inherits from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>, + otherwise inherits from <a class="link" href="integral_constant.html" title="integral_constant">false_type</a>. + </p> +<p> + The default behaviour (<code class="computeroutput"><span class="identifier">Ret</span><span class="special">=</span><span class="identifier">dont_care</span></code>) + is to not check for the return value of prefix <code class="computeroutput"><span class="keyword">operator</span><span class="special">!</span></code>. If <code class="computeroutput"><span class="identifier">Ret</span></code> + is different from the default <code class="computeroutput"><span class="identifier">dont_care</span></code> + type, the return value is checked to be convertible to <code class="computeroutput"><span class="identifier">Ret</span></code>. + Convertible to <code class="computeroutput"><span class="identifier">Ret</span></code> means + that the return value of the operator can be used as argument to a function + expecting <code class="computeroutput"><span class="identifier">Ret</span></code>: +</p> +<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">Ret</span><span class="special">);</span> +<span class="identifier">Rhs</span> <span class="identifier">rhs</span><span class="special">;</span> +<span class="identifier">f</span><span class="special">(!</span><span class="identifier">rhs</span><span class="special">);</span> <span class="comment">// is valid if has_logical_not<Rhs, Ret>::value==true</span> +</pre> +<p> + If <code class="computeroutput"><span class="identifier">Ret</span><span class="special">=</span><span class="keyword">void</span></code>, the return type is checked to be exactly + <code class="computeroutput"><span class="keyword">void</span></code>. + </p> +<p> + <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"><span class="preprocessor">#include</span> + <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_logical_not</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_operator</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + </p> +<p> + <span class="bold"><strong>Examples:</strong></span> + </p> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_logical_not</span><span class="special"><</span><span class="identifier">Rhs</span><span class="special">,</span> <span class="identifier">Ret</span><span class="special">>::</span><span class="identifier">value_type</span></code> is the type <code class="computeroutput"><span class="keyword">bool</span></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_logical_not</span><span class="special"><</span><span class="identifier">Rhs</span><span class="special">,</span> <span class="identifier">Ret</span><span class="special">>::</span><span class="identifier">value</span></code> is a <code class="computeroutput"><span class="keyword">bool</span></code> + integral constant expression. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_logical_not</span><span class="special"><</span><span class="keyword">int</span><span class="special">>::</span><span class="identifier">value</span></code> is a <code class="computeroutput"><span class="keyword">bool</span></code> + integral constant expression that evaluates to <code class="computeroutput"><span class="keyword">true</span></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_logical_not</span><span class="special"><</span><span class="keyword">bool</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_logical_not</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">bool</span><span class="special">></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_logical_not</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">long</span><span class="special">></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_logical_not</span><span class="special"><</span><span class="keyword">double</span><span class="special">,</span> <span class="keyword">double</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_logical_not</span><span class="special"><</span><span class="keyword">double</span><span class="special">,</span> <span class="keyword">bool</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_logical_not</span><span class="special"><</span><span class="keyword">const</span> <span class="keyword">bool</span><span class="special">></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_logical_not</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>. + </p></blockquote></div> +<p> + <span class="bold"><strong>See also:</strong></span> <a class="link" href="../category/value_traits/operators.html" title="Operator Type Traits">Operator + Type Traits</a> + </p> +<p> + <span class="bold"><strong>Limitation:</strong></span> + </p> +<div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"> + Requires a compiler with working SFINAE. + </li></ul></div> +<p> + <span class="bold"><strong>Known issues:</strong></span> + </p> +<div class="itemizedlist"><ul class="itemizedlist" type="disc"> +<li class="listitem"> + This trait cannot detect whether prefix <code class="computeroutput"><span class="keyword">operator</span><span class="special">!</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">!</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">Rhs</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_logical_not</span><span class="special"><</span><span class="identifier">Rhs</span><span class="special">></span></code> + will produce a compiler error. For this reason <code class="computeroutput"><span class="identifier">has_logical_not</span></code> + cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">!</span></code> + or not. +<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">!();</span> <span class="special">};</span> +<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_logical_not</span><span class="special"><</span><span class="identifier">A</span><span class="special">>::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator!() is private</span> +</pre> + </li> +<li class="listitem"> + There is an issue if the operator exists only for type <code class="computeroutput"><span class="identifier">A</span></code> and <code class="computeroutput"><span class="identifier">B</span></code> + is convertible to <code class="computeroutput"><span class="identifier">A</span></code>. + In this case, the compiler will report an ambiguous overload. +<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span> +<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">!(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&);</span> +<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span> +<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_logical_not</span><span class="special"><</span><span class="identifier">A</span><span class="special">>::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine</span> +<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_logical_not</span><span class="special"><</span><span class="identifier">B</span><span class="special">>::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambiguous overload</span> +</pre> + </li> +<li class="listitem"> + There is an issue when applying this trait to template classes. If <code class="computeroutput"><span class="keyword">operator</span><span class="special">!</span></code> + is defined but does not bind for a given template type, it is still detected + by the trait which returns <code class="computeroutput"><span class="keyword">true</span></code> + instead of <code class="computeroutput"><span class="keyword">false</span></code>. Example: + +<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_logical_not</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span> +<span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">iostream</span><span class="special">></span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">contains</span> <span class="special">{</span> <span class="identifier">T</span> <span class="identifier">data</span><span class="special">;</span> <span class="special">};</span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">!(</span><span class="keyword">const</span> <span class="identifier">contains</span><span class="special"><</span><span class="identifier">T</span><span class="special">></span> <span class="special">&</span><span class="identifier">rhs</span><span class="special">)</span> <span class="special">{</span> + <span class="keyword">return</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">rhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">);</span> +<span class="special">}</span> + +<span class="keyword">class</span> <span class="identifier">bad</span> <span class="special">{</span> <span class="special">};</span> +<span class="keyword">class</span> <span class="identifier">good</span> <span class="special">{</span> <span class="special">};</span> +<span class="keyword">bool</span> <span class="identifier">f</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">good</span><span class="special">&)</span> <span class="special">{</span> <span class="special">}</span> + +<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span> <span class="special">{</span> + <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special"><<</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">boolalpha</span><span class="special">;</span> + <span class="comment">// works fine for contains<good></span> + <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special"><<</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_logical_not</span><span class="special"><</span> <span class="identifier">contains</span><span class="special"><</span> <span class="identifier">good</span> <span class="special">></span> <span class="special">>::</span><span class="identifier">value</span><span class="special"><<</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true</span> + <span class="identifier">contains</span><span class="special"><</span><span class="identifier">good</span><span class="special">></span> <span class="identifier">g</span><span class="special">;</span> + <span class="special">!</span><span class="identifier">g</span><span class="special">;</span> <span class="comment">// ok</span> + <span class="comment">// does not work for contains<bad></span> + <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special"><<</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_logical_not</span><span class="special"><</span> <span class="identifier">contains</span><span class="special"><</span> <span class="identifier">bad</span> <span class="special">></span> <span class="special">>::</span><span class="identifier">value</span><span class="special"><<</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true, should be false</span> + <span class="identifier">contains</span><span class="special"><</span><span class="identifier">bad</span><span class="special">></span> <span class="identifier">b</span><span class="special">;</span> + <span class="special">!</span><span class="identifier">b</span><span class="special">;</span> <span class="comment">// compile time error</span> + <span class="keyword">return</span> <span class="number">0</span><span class="special">;</span> +<span class="special">}</span> +</pre> + </li> +<li class="listitem"> + <code class="computeroutput"><span class="keyword">volatile</span></code> qualifier is not + properly handled and would lead to undefined behavior + </li> +</ul></div> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="has_logical_and.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="has_logical_or.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/reference/has_logical_or.html b/libs/type_traits/doc/html/boost_typetraits/reference/has_logical_or.html new file mode 100644 index 0000000000..b697960b9d --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/reference/has_logical_or.html @@ -0,0 +1,195 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>has_logical_or</title> +<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../reference.html" title="Alphabetical Reference"> +<link rel="prev" href="has_logical_not.html" title="has_logical_not"> +<link rel="next" href="has_minus.html" title="has_minus"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td> +<td align="center"><a href="../../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="has_logical_not.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="has_minus.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h3 class="title"> +<a name="boost_typetraits.reference.has_logical_or"></a><a class="link" href="has_logical_or.html" title="has_logical_or">has_logical_or</a> +</h3></div></div></div> +<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">Lhs</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Rhs</span><span class="special">=</span><span class="identifier">Lhs</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Ret</span><span class="special">=</span><span class="identifier">dont_care</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">has_logical_or</span> <span class="special">:</span> <span class="keyword">public</span> <em class="replaceable"><code><a class="link" href="integral_constant.html" title="integral_constant">true_type</a>-or-<a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code></em> <span class="special">{};</span> +</pre> +<p> + <span class="bold"><strong>Inherits:</strong></span> If (i) <code class="computeroutput"><span class="identifier">lhs</span></code> + of type <code class="computeroutput"><span class="identifier">Lhs</span></code> and <code class="computeroutput"><span class="identifier">rhs</span></code> of type <code class="computeroutput"><span class="identifier">Rhs</span></code> + can be used in expression <code class="computeroutput"><span class="identifier">lhs</span><span class="special">||</span><span class="identifier">rhs</span></code>, + and (ii) <code class="computeroutput"><span class="identifier">Ret</span><span class="special">=</span><span class="identifier">dont_care</span></code> or the result of expression + <code class="computeroutput"><span class="identifier">lhs</span><span class="special">||</span><span class="identifier">rhs</span></code> is convertible to <code class="computeroutput"><span class="identifier">Ret</span></code> + then inherits from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>, + otherwise inherits from <a class="link" href="integral_constant.html" title="integral_constant">false_type</a>. + </p> +<p> + The default behaviour (<code class="computeroutput"><span class="identifier">Ret</span><span class="special">=</span><span class="identifier">dont_care</span></code>) + is to not check for the return value of binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">||</span></code>. If <code class="computeroutput"><span class="identifier">Ret</span></code> + is different from the default <code class="computeroutput"><span class="identifier">dont_care</span></code> + type, the return value is checked to be convertible to <code class="computeroutput"><span class="identifier">Ret</span></code>. + Convertible to <code class="computeroutput"><span class="identifier">Ret</span></code> means + that the return value of the operator can be used as argument to a function + expecting <code class="computeroutput"><span class="identifier">Ret</span></code>: +</p> +<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">Ret</span><span class="special">);</span> +<span class="identifier">Lhs</span> <span class="identifier">lhs</span><span class="special">;</span> +<span class="identifier">Rhs</span> <span class="identifier">rhs</span><span class="special">;</span> +<span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">||</span><span class="identifier">rhs</span><span class="special">);</span> <span class="comment">// is valid if has_logical_or<Lhs, Rhs, Ret>::value==true</span> +</pre> +<p> + If <code class="computeroutput"><span class="identifier">Ret</span><span class="special">=</span><span class="keyword">void</span></code>, the return type is checked to be exactly + <code class="computeroutput"><span class="keyword">void</span></code>. + </p> +<p> + <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"><span class="preprocessor">#include</span> + <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_logical_or</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_operator</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + </p> +<p> + <span class="bold"><strong>Examples:</strong></span> + </p> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_logical_or</span><span class="special"><</span><span class="identifier">Lhs</span><span class="special">,</span> <span class="identifier">Rhs</span><span class="special">,</span> <span class="identifier">Ret</span><span class="special">>::</span><span class="identifier">value_type</span></code> is the type <code class="computeroutput"><span class="keyword">bool</span></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_logical_or</span><span class="special"><</span><span class="identifier">Lhs</span><span class="special">,</span> <span class="identifier">Rhs</span><span class="special">,</span> <span class="identifier">Ret</span><span class="special">>::</span><span class="identifier">value</span></code> is a <code class="computeroutput"><span class="keyword">bool</span></code> + integral constant expression. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_logical_or</span><span class="special"><</span><span class="keyword">int</span><span class="special">>::</span><span class="identifier">value</span></code> is a <code class="computeroutput"><span class="keyword">bool</span></code> + integral constant expression that evaluates to <code class="computeroutput"><span class="keyword">true</span></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_logical_or</span><span class="special"><</span><span class="keyword">bool</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_logical_or</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="keyword">bool</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_logical_or</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="keyword">long</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_logical_or</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">bool</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_logical_or</span><span class="special"><</span><span class="keyword">const</span> <span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">>::</span><span class="identifier">value</span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_logical_or</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>. + </p></blockquote></div> +<p> + <span class="bold"><strong>See also:</strong></span> <a class="link" href="../category/value_traits/operators.html" title="Operator Type Traits">Operator + Type Traits</a> + </p> +<p> + <span class="bold"><strong>Limitation:</strong></span> + </p> +<div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"> + Requires a compiler with working SFINAE. + </li></ul></div> +<p> + <span class="bold"><strong>Known issues:</strong></span> + </p> +<div class="itemizedlist"><ul class="itemizedlist" type="disc"> +<li class="listitem"> + This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">||</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">||</span></code> + is defined as a private member of <code class="computeroutput"><span class="identifier">Lhs</span></code> + then instantiating <code class="computeroutput"><span class="identifier">has_logical_or</span><span class="special"><</span><span class="identifier">Lhs</span><span class="special">></span></code> will produce a compiler error. For + this reason <code class="computeroutput"><span class="identifier">has_logical_or</span></code> + cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">||</span></code> + or not. +<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">||(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&);</span> <span class="special">};</span> +<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_logical_or</span><span class="special"><</span><span class="identifier">A</span><span class="special">>::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator||(const A&) is private</span> +</pre> + </li> +<li class="listitem"> + There is an issue if the operator exists only for type <code class="computeroutput"><span class="identifier">A</span></code> and <code class="computeroutput"><span class="identifier">B</span></code> + is convertible to <code class="computeroutput"><span class="identifier">A</span></code>. + In this case, the compiler will report an ambiguous overload. +<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span> +<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">||(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&,</span> <span class="keyword">const</span> <span class="identifier">A</span><span class="special">&);</span> +<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span> +<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_logical_or</span><span class="special"><</span><span class="identifier">A</span><span class="special">>::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine</span> +<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_logical_or</span><span class="special"><</span><span class="identifier">B</span><span class="special">>::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambiguous overload</span> +</pre> + </li> +<li class="listitem"> + There is an issue when applying this trait to template classes. If <code class="computeroutput"><span class="keyword">operator</span><span class="special">||</span></code> + is defined but does not bind for a given template type, it is still detected + by the trait which returns <code class="computeroutput"><span class="keyword">true</span></code> + instead of <code class="computeroutput"><span class="keyword">false</span></code>. Example: + +<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_logical_or</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span> +<span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">iostream</span><span class="special">></span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">contains</span> <span class="special">{</span> <span class="identifier">T</span> <span class="identifier">data</span><span class="special">;</span> <span class="special">};</span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">||(</span><span class="keyword">const</span> <span class="identifier">contains</span><span class="special"><</span><span class="identifier">T</span><span class="special">></span> <span class="special">&</span><span class="identifier">lhs</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">contains</span><span class="special"><</span><span class="identifier">T</span><span class="special">></span> <span class="special">&</span><span class="identifier">rhs</span><span class="special">)</span> <span class="special">{</span> + <span class="keyword">return</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">,</span> <span class="identifier">rhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">);</span> +<span class="special">}</span> + +<span class="keyword">class</span> <span class="identifier">bad</span> <span class="special">{</span> <span class="special">};</span> +<span class="keyword">class</span> <span class="identifier">good</span> <span class="special">{</span> <span class="special">};</span> +<span class="keyword">bool</span> <span class="identifier">f</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">good</span><span class="special">&,</span> <span class="keyword">const</span> <span class="identifier">good</span><span class="special">&)</span> <span class="special">{</span> <span class="special">}</span> + +<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span> <span class="special">{</span> + <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special"><<</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">boolalpha</span><span class="special">;</span> + <span class="comment">// works fine for contains<good></span> + <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special"><<</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_logical_or</span><span class="special"><</span> <span class="identifier">contains</span><span class="special"><</span> <span class="identifier">good</span> <span class="special">></span> <span class="special">>::</span><span class="identifier">value</span><span class="special"><<</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true</span> + <span class="identifier">contains</span><span class="special"><</span><span class="identifier">good</span><span class="special">></span> <span class="identifier">g</span><span class="special">;</span> + <span class="identifier">g</span><span class="special">||</span><span class="identifier">g</span><span class="special">;</span> <span class="comment">// ok</span> + <span class="comment">// does not work for contains<bad></span> + <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special"><<</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_logical_or</span><span class="special"><</span> <span class="identifier">contains</span><span class="special"><</span> <span class="identifier">bad</span> <span class="special">></span> <span class="special">>::</span><span class="identifier">value</span><span class="special"><<</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true, should be false</span> + <span class="identifier">contains</span><span class="special"><</span><span class="identifier">bad</span><span class="special">></span> <span class="identifier">b</span><span class="special">;</span> + <span class="identifier">b</span><span class="special">||</span><span class="identifier">b</span><span class="special">;</span> <span class="comment">// compile time error</span> + <span class="keyword">return</span> <span class="number">0</span><span class="special">;</span> +<span class="special">}</span> +</pre> + </li> +<li class="listitem"> + <code class="computeroutput"><span class="keyword">volatile</span></code> qualifier is not + properly handled and would lead to undefined behavior + </li> +</ul></div> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="has_logical_not.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="has_minus.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/reference/has_minus.html b/libs/type_traits/doc/html/boost_typetraits/reference/has_minus.html new file mode 100644 index 0000000000..ad4a2f64e8 --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/reference/has_minus.html @@ -0,0 +1,196 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>has_minus</title> +<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../reference.html" title="Alphabetical Reference"> +<link rel="prev" href="has_logical_or.html" title="has_logical_or"> +<link rel="next" href="has_minus_assign.html" title="has_minus_assign"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td> +<td align="center"><a href="../../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="has_logical_or.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="has_minus_assign.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h3 class="title"> +<a name="boost_typetraits.reference.has_minus"></a><a class="link" href="has_minus.html" title="has_minus">has_minus</a> +</h3></div></div></div> +<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">Lhs</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Rhs</span><span class="special">=</span><span class="identifier">Lhs</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Ret</span><span class="special">=</span><span class="identifier">dont_care</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">has_minus</span> <span class="special">:</span> <span class="keyword">public</span> <em class="replaceable"><code><a class="link" href="integral_constant.html" title="integral_constant">true_type</a>-or-<a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code></em> <span class="special">{};</span> +</pre> +<p> + <span class="bold"><strong>Inherits:</strong></span> If (i) <code class="computeroutput"><span class="identifier">lhs</span></code> + of type <code class="computeroutput"><span class="identifier">Lhs</span></code> and <code class="computeroutput"><span class="identifier">rhs</span></code> of type <code class="computeroutput"><span class="identifier">Rhs</span></code> + can be used in expression <code class="computeroutput"><span class="identifier">lhs</span><span class="special">-</span><span class="identifier">rhs</span></code>, and + (ii) <code class="computeroutput"><span class="identifier">Ret</span><span class="special">=</span><span class="identifier">dont_care</span></code> or the result of expression + <code class="computeroutput"><span class="identifier">lhs</span><span class="special">-</span><span class="identifier">rhs</span></code> is convertible to <code class="computeroutput"><span class="identifier">Ret</span></code> + then inherits from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>, + otherwise inherits from <a class="link" href="integral_constant.html" title="integral_constant">false_type</a>. + </p> +<p> + The default behaviour (<code class="computeroutput"><span class="identifier">Ret</span><span class="special">=</span><span class="identifier">dont_care</span></code>) + is to not check for the return value of binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">-</span></code>. If <code class="computeroutput"><span class="identifier">Ret</span></code> + is different from the default <code class="computeroutput"><span class="identifier">dont_care</span></code> + type, the return value is checked to be convertible to <code class="computeroutput"><span class="identifier">Ret</span></code>. + Convertible to <code class="computeroutput"><span class="identifier">Ret</span></code> means + that the return value of the operator can be used as argument to a function + expecting <code class="computeroutput"><span class="identifier">Ret</span></code>: +</p> +<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">Ret</span><span class="special">);</span> +<span class="identifier">Lhs</span> <span class="identifier">lhs</span><span class="special">;</span> +<span class="identifier">Rhs</span> <span class="identifier">rhs</span><span class="special">;</span> +<span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">-</span><span class="identifier">rhs</span><span class="special">);</span> <span class="comment">// is valid if has_minus<Lhs, Rhs, Ret>::value==true</span> +</pre> +<p> + If <code class="computeroutput"><span class="identifier">Ret</span><span class="special">=</span><span class="keyword">void</span></code>, the return type is checked to be exactly + <code class="computeroutput"><span class="keyword">void</span></code>. + </p> +<p> + <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"><span class="preprocessor">#include</span> + <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_minus</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_operator</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + </p> +<p> + <span class="bold"><strong>Examples:</strong></span> + </p> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_minus</span><span class="special"><</span><span class="identifier">Lhs</span><span class="special">,</span> <span class="identifier">Rhs</span><span class="special">,</span> <span class="identifier">Ret</span><span class="special">>::</span><span class="identifier">value_type</span></code> is the type <code class="computeroutput"><span class="keyword">bool</span></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_minus</span><span class="special"><</span><span class="identifier">Lhs</span><span class="special">,</span> <span class="identifier">Rhs</span><span class="special">,</span> <span class="identifier">Ret</span><span class="special">>::</span><span class="identifier">value</span></code> is a <code class="computeroutput"><span class="keyword">bool</span></code> + integral constant expression. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_minus</span><span class="special"><</span><span class="keyword">int</span><span class="special">>::</span><span class="identifier">value</span></code> is a <code class="computeroutput"><span class="keyword">bool</span></code> + integral constant expression that evaluates to <code class="computeroutput"><span class="keyword">true</span></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_minus</span><span class="special"><</span><span class="keyword">long</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_minus</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_minus</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="keyword">long</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_minus</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">double</span><span class="special">></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_minus</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">int</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_minus</span><span class="special"><</span><span class="keyword">const</span> <span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">>::</span><span class="identifier">value</span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_minus</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>. + </p></blockquote></div> +<p> + <span class="bold"><strong>See also:</strong></span> <a class="link" href="../category/value_traits/operators.html" title="Operator Type Traits">Operator + Type Traits</a> + </p> +<p> + <span class="bold"><strong>Limitation:</strong></span> + </p> +<div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"> + Requires a compiler with working SFINAE. + </li></ul></div> +<p> + <span class="bold"><strong>Known issues:</strong></span> + </p> +<div class="itemizedlist"><ul class="itemizedlist" type="disc"> +<li class="listitem"> + This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">-</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">-</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">Lhs</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_minus</span><span class="special"><</span><span class="identifier">Lhs</span><span class="special">></span></code> + will produce a compiler error. For this reason <code class="computeroutput"><span class="identifier">has_minus</span></code> + cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">-</span></code> + or not. +<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">-(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&);</span> <span class="special">};</span> +<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_minus</span><span class="special"><</span><span class="identifier">A</span><span class="special">>::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator-(const A&) is private</span> +</pre> + </li> +<li class="listitem"> + There is an issue if the operator exists only for type <code class="computeroutput"><span class="identifier">A</span></code> and <code class="computeroutput"><span class="identifier">B</span></code> + is convertible to <code class="computeroutput"><span class="identifier">A</span></code>. + In this case, the compiler will report an ambiguous overload. +<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span> +<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">-(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&,</span> <span class="keyword">const</span> <span class="identifier">A</span><span class="special">&);</span> +<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span> +<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_minus</span><span class="special"><</span><span class="identifier">A</span><span class="special">>::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine</span> +<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_minus</span><span class="special"><</span><span class="identifier">B</span><span class="special">>::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambiguous overload</span> +</pre> + </li> +<li class="listitem"> + There is an issue when applying this trait to template classes. If <code class="computeroutput"><span class="keyword">operator</span><span class="special">-</span></code> + is defined but does not bind for a given template type, it is still detected + by the trait which returns <code class="computeroutput"><span class="keyword">true</span></code> + instead of <code class="computeroutput"><span class="keyword">false</span></code>. Example: + +<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_minus</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span> +<span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">iostream</span><span class="special">></span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">contains</span> <span class="special">{</span> <span class="identifier">T</span> <span class="identifier">data</span><span class="special">;</span> <span class="special">};</span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">-(</span><span class="keyword">const</span> <span class="identifier">contains</span><span class="special"><</span><span class="identifier">T</span><span class="special">></span> <span class="special">&</span><span class="identifier">lhs</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">contains</span><span class="special"><</span><span class="identifier">T</span><span class="special">></span> <span class="special">&</span><span class="identifier">rhs</span><span class="special">)</span> <span class="special">{</span> + <span class="keyword">return</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">,</span> <span class="identifier">rhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">);</span> +<span class="special">}</span> + +<span class="keyword">class</span> <span class="identifier">bad</span> <span class="special">{</span> <span class="special">};</span> +<span class="keyword">class</span> <span class="identifier">good</span> <span class="special">{</span> <span class="special">};</span> +<span class="keyword">bool</span> <span class="identifier">f</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">good</span><span class="special">&,</span> <span class="keyword">const</span> <span class="identifier">good</span><span class="special">&)</span> <span class="special">{</span> <span class="special">}</span> + +<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span> <span class="special">{</span> + <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special"><<</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">boolalpha</span><span class="special">;</span> + <span class="comment">// works fine for contains<good></span> + <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special"><<</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_minus</span><span class="special"><</span> <span class="identifier">contains</span><span class="special"><</span> <span class="identifier">good</span> <span class="special">></span> <span class="special">>::</span><span class="identifier">value</span><span class="special"><<</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true</span> + <span class="identifier">contains</span><span class="special"><</span><span class="identifier">good</span><span class="special">></span> <span class="identifier">g</span><span class="special">;</span> + <span class="identifier">g</span><span class="special">-</span><span class="identifier">g</span><span class="special">;</span> <span class="comment">// ok</span> + <span class="comment">// does not work for contains<bad></span> + <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special"><<</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_minus</span><span class="special"><</span> <span class="identifier">contains</span><span class="special"><</span> <span class="identifier">bad</span> <span class="special">></span> <span class="special">>::</span><span class="identifier">value</span><span class="special"><<</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true, should be false</span> + <span class="identifier">contains</span><span class="special"><</span><span class="identifier">bad</span><span class="special">></span> <span class="identifier">b</span><span class="special">;</span> + <span class="identifier">b</span><span class="special">-</span><span class="identifier">b</span><span class="special">;</span> <span class="comment">// compile time error</span> + <span class="keyword">return</span> <span class="number">0</span><span class="special">;</span> +<span class="special">}</span> +</pre> + </li> +<li class="listitem"> + <code class="computeroutput"><span class="keyword">volatile</span></code> qualifier is not + properly handled and would lead to undefined behavior + </li> +</ul></div> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="has_logical_or.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="has_minus_assign.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/reference/has_minus_assign.html b/libs/type_traits/doc/html/boost_typetraits/reference/has_minus_assign.html new file mode 100644 index 0000000000..ee05bc6f3a --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/reference/has_minus_assign.html @@ -0,0 +1,198 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>has_minus_assign</title> +<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../reference.html" title="Alphabetical Reference"> +<link rel="prev" href="has_minus.html" title="has_minus"> +<link rel="next" href="has_modulus.html" title="has_modulus"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td> +<td align="center"><a href="../../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="has_minus.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="has_modulus.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h3 class="title"> +<a name="boost_typetraits.reference.has_minus_assign"></a><a class="link" href="has_minus_assign.html" title="has_minus_assign">has_minus_assign</a> +</h3></div></div></div> +<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">Lhs</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Rhs</span><span class="special">=</span><span class="identifier">Lhs</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Ret</span><span class="special">=</span><span class="identifier">dont_care</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">has_minus_assign</span> <span class="special">:</span> <span class="keyword">public</span> <em class="replaceable"><code><a class="link" href="integral_constant.html" title="integral_constant">true_type</a>-or-<a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code></em> <span class="special">{};</span> +</pre> +<p> + <span class="bold"><strong>Inherits:</strong></span> If (i) <code class="computeroutput"><span class="identifier">lhs</span></code> + of type <code class="computeroutput"><span class="identifier">Lhs</span></code> and <code class="computeroutput"><span class="identifier">rhs</span></code> of type <code class="computeroutput"><span class="identifier">Rhs</span></code> + can be used in expression <code class="computeroutput"><span class="identifier">lhs</span><span class="special">-=</span><span class="identifier">rhs</span></code>, + and (ii) <code class="computeroutput"><span class="identifier">Ret</span><span class="special">=</span><span class="identifier">dont_care</span></code> or the result of expression + <code class="computeroutput"><span class="identifier">lhs</span><span class="special">-=</span><span class="identifier">rhs</span></code> is convertible to <code class="computeroutput"><span class="identifier">Ret</span></code> + then inherits from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>, + otherwise inherits from <a class="link" href="integral_constant.html" title="integral_constant">false_type</a>. + </p> +<p> + The default behaviour (<code class="computeroutput"><span class="identifier">Ret</span><span class="special">=</span><span class="identifier">dont_care</span></code>) + is to not check for the return value of binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">-=</span></code>. If <code class="computeroutput"><span class="identifier">Ret</span></code> + is different from the default <code class="computeroutput"><span class="identifier">dont_care</span></code> + type, the return value is checked to be convertible to <code class="computeroutput"><span class="identifier">Ret</span></code>. + Convertible to <code class="computeroutput"><span class="identifier">Ret</span></code> means + that the return value of the operator can be used as argument to a function + expecting <code class="computeroutput"><span class="identifier">Ret</span></code>: +</p> +<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">Ret</span><span class="special">);</span> +<span class="identifier">Lhs</span> <span class="identifier">lhs</span><span class="special">;</span> +<span class="identifier">Rhs</span> <span class="identifier">rhs</span><span class="special">;</span> +<span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">-=</span><span class="identifier">rhs</span><span class="special">);</span> <span class="comment">// is valid if has_minus_assign<Lhs, Rhs, Ret>::value==true</span> +</pre> +<p> + If <code class="computeroutput"><span class="identifier">Ret</span><span class="special">=</span><span class="keyword">void</span></code>, the return type is checked to be exactly + <code class="computeroutput"><span class="keyword">void</span></code>. + </p> +<p> + <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"><span class="preprocessor">#include</span> + <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_minus_assign</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_operator</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + </p> +<p> + <span class="bold"><strong>Examples:</strong></span> + </p> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_minus_assign</span><span class="special"><</span><span class="identifier">Lhs</span><span class="special">,</span> <span class="identifier">Rhs</span><span class="special">,</span> <span class="identifier">Ret</span><span class="special">>::</span><span class="identifier">value_type</span></code> is the type <code class="computeroutput"><span class="keyword">bool</span></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_minus_assign</span><span class="special"><</span><span class="identifier">Lhs</span><span class="special">,</span> <span class="identifier">Rhs</span><span class="special">,</span> <span class="identifier">Ret</span><span class="special">>::</span><span class="identifier">value</span></code> is a <code class="computeroutput"><span class="keyword">bool</span></code> + integral constant expression. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_minus_assign</span><span class="special"><</span><span class="keyword">int</span><span class="special">>::</span><span class="identifier">value</span></code> is a <code class="computeroutput"><span class="keyword">bool</span></code> + integral constant expression that evaluates to <code class="computeroutput"><span class="keyword">true</span></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_minus_assign</span><span class="special"><</span><span class="keyword">long</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_minus_assign</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_minus_assign</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="keyword">long</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_minus_assign</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">double</span><span class="special">></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_minus_assign</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">int</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_minus_assign</span><span class="special"><</span><span class="keyword">const</span> <span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">>::</span><span class="identifier">value</span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_minus_assign</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>. + </p></blockquote></div> +<p> + <span class="bold"><strong>See also:</strong></span> <a class="link" href="../category/value_traits/operators.html" title="Operator Type Traits">Operator + Type Traits</a> + </p> +<p> + <span class="bold"><strong>Limitation:</strong></span> + </p> +<div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"> + Requires a compiler with working SFINAE. + </li></ul></div> +<p> + <span class="bold"><strong>Known issues:</strong></span> + </p> +<div class="itemizedlist"><ul class="itemizedlist" type="disc"> +<li class="listitem"> + This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">-=</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">-=</span></code> + is defined as a private member of <code class="computeroutput"><span class="identifier">Lhs</span></code> + then instantiating <code class="computeroutput"><span class="identifier">has_minus_assign</span><span class="special"><</span><span class="identifier">Lhs</span><span class="special">></span></code> will produce a compiler error. For + this reason <code class="computeroutput"><span class="identifier">has_minus_assign</span></code> + cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">-=</span></code> + or not. +<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">-=(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&);</span> <span class="special">};</span> +<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_minus_assign</span><span class="special"><</span><span class="identifier">A</span><span class="special">>::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator-=(const A&) is private</span> +</pre> + </li> +<li class="listitem"> + There is an issue if the operator exists only for type <code class="computeroutput"><span class="identifier">A</span></code> and <code class="computeroutput"><span class="identifier">B</span></code> + is convertible to <code class="computeroutput"><span class="identifier">A</span></code>. + In this case, the compiler will report an ambiguous overload. +<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span> +<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">-=(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&,</span> <span class="keyword">const</span> <span class="identifier">A</span><span class="special">&);</span> +<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span> +<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_minus_assign</span><span class="special"><</span><span class="identifier">A</span><span class="special">>::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine</span> +<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_minus_assign</span><span class="special"><</span><span class="identifier">B</span><span class="special">>::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambiguous overload</span> +</pre> + </li> +<li class="listitem"> + There is an issue when applying this trait to template classes. If <code class="computeroutput"><span class="keyword">operator</span><span class="special">-=</span></code> + is defined but does not bind for a given template type, it is still detected + by the trait which returns <code class="computeroutput"><span class="keyword">true</span></code> + instead of <code class="computeroutput"><span class="keyword">false</span></code>. Example: + +<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_minus_assign</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span> +<span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">iostream</span><span class="special">></span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">contains</span> <span class="special">{</span> <span class="identifier">T</span> <span class="identifier">data</span><span class="special">;</span> <span class="special">};</span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">-=(</span><span class="keyword">const</span> <span class="identifier">contains</span><span class="special"><</span><span class="identifier">T</span><span class="special">></span> <span class="special">&</span><span class="identifier">lhs</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">contains</span><span class="special"><</span><span class="identifier">T</span><span class="special">></span> <span class="special">&</span><span class="identifier">rhs</span><span class="special">)</span> <span class="special">{</span> + <span class="keyword">return</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">,</span> <span class="identifier">rhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">);</span> +<span class="special">}</span> + +<span class="keyword">class</span> <span class="identifier">bad</span> <span class="special">{</span> <span class="special">};</span> +<span class="keyword">class</span> <span class="identifier">good</span> <span class="special">{</span> <span class="special">};</span> +<span class="keyword">bool</span> <span class="identifier">f</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">good</span><span class="special">&,</span> <span class="keyword">const</span> <span class="identifier">good</span><span class="special">&)</span> <span class="special">{</span> <span class="special">}</span> + +<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span> <span class="special">{</span> + <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special"><<</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">boolalpha</span><span class="special">;</span> + <span class="comment">// works fine for contains<good></span> + <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special"><<</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_minus_assign</span><span class="special"><</span> <span class="identifier">contains</span><span class="special"><</span> <span class="identifier">good</span> <span class="special">></span> <span class="special">>::</span><span class="identifier">value</span><span class="special"><<</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true</span> + <span class="identifier">contains</span><span class="special"><</span><span class="identifier">good</span><span class="special">></span> <span class="identifier">g</span><span class="special">;</span> + <span class="identifier">g</span><span class="special">-=</span><span class="identifier">g</span><span class="special">;</span> <span class="comment">// ok</span> + <span class="comment">// does not work for contains<bad></span> + <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special"><<</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_minus_assign</span><span class="special"><</span> <span class="identifier">contains</span><span class="special"><</span> <span class="identifier">bad</span> <span class="special">></span> <span class="special">>::</span><span class="identifier">value</span><span class="special"><<</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true, should be false</span> + <span class="identifier">contains</span><span class="special"><</span><span class="identifier">bad</span><span class="special">></span> <span class="identifier">b</span><span class="special">;</span> + <span class="identifier">b</span><span class="special">-=</span><span class="identifier">b</span><span class="special">;</span> <span class="comment">// compile time error</span> + <span class="keyword">return</span> <span class="number">0</span><span class="special">;</span> +<span class="special">}</span> +</pre> + </li> +<li class="listitem"> + <code class="computeroutput"><span class="keyword">volatile</span></code> qualifier is not + properly handled and would lead to undefined behavior + </li> +</ul></div> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="has_minus.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="has_modulus.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/reference/has_modulus.html b/libs/type_traits/doc/html/boost_typetraits/reference/has_modulus.html new file mode 100644 index 0000000000..d55b7d964d --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/reference/has_modulus.html @@ -0,0 +1,189 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>has_modulus</title> +<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../reference.html" title="Alphabetical Reference"> +<link rel="prev" href="has_minus_assign.html" title="has_minus_assign"> +<link rel="next" href="has_modulus_assign.html" title="has_modulus_assign"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td> +<td align="center"><a href="../../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="has_minus_assign.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="has_modulus_assign.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h3 class="title"> +<a name="boost_typetraits.reference.has_modulus"></a><a class="link" href="has_modulus.html" title="has_modulus">has_modulus</a> +</h3></div></div></div> +<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">Lhs</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Rhs</span><span class="special">=</span><span class="identifier">Lhs</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Ret</span><span class="special">=</span><span class="identifier">dont_care</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">has_modulus</span> <span class="special">:</span> <span class="keyword">public</span> <em class="replaceable"><code><a class="link" href="integral_constant.html" title="integral_constant">true_type</a>-or-<a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code></em> <span class="special">{};</span> +</pre> +<p> + <span class="bold"><strong>Inherits:</strong></span> If (i) <code class="computeroutput"><span class="identifier">lhs</span></code> + of type <code class="computeroutput"><span class="identifier">Lhs</span></code> and <code class="computeroutput"><span class="identifier">rhs</span></code> of type <code class="computeroutput"><span class="identifier">Rhs</span></code> + can be used in expression <code class="computeroutput"><span class="identifier">lhs</span><span class="special">%</span><span class="identifier">rhs</span></code>, and + (ii) <code class="computeroutput"><span class="identifier">Ret</span><span class="special">=</span><span class="identifier">dont_care</span></code> or the result of expression + <code class="computeroutput"><span class="identifier">lhs</span><span class="special">%</span><span class="identifier">rhs</span></code> is convertible to <code class="computeroutput"><span class="identifier">Ret</span></code> + then inherits from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>, + otherwise inherits from <a class="link" href="integral_constant.html" title="integral_constant">false_type</a>. + </p> +<p> + The default behaviour (<code class="computeroutput"><span class="identifier">Ret</span><span class="special">=</span><span class="identifier">dont_care</span></code>) + is to not check for the return value of binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">%</span></code>. If <code class="computeroutput"><span class="identifier">Ret</span></code> + is different from the default <code class="computeroutput"><span class="identifier">dont_care</span></code> + type, the return value is checked to be convertible to <code class="computeroutput"><span class="identifier">Ret</span></code>. + Convertible to <code class="computeroutput"><span class="identifier">Ret</span></code> means + that the return value of the operator can be used as argument to a function + expecting <code class="computeroutput"><span class="identifier">Ret</span></code>: +</p> +<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">Ret</span><span class="special">);</span> +<span class="identifier">Lhs</span> <span class="identifier">lhs</span><span class="special">;</span> +<span class="identifier">Rhs</span> <span class="identifier">rhs</span><span class="special">;</span> +<span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">%</span><span class="identifier">rhs</span><span class="special">);</span> <span class="comment">// is valid if has_modulus<Lhs, Rhs, Ret>::value==true</span> +</pre> +<p> + If <code class="computeroutput"><span class="identifier">Ret</span><span class="special">=</span><span class="keyword">void</span></code>, the return type is checked to be exactly + <code class="computeroutput"><span class="keyword">void</span></code>. + </p> +<p> + <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"><span class="preprocessor">#include</span> + <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_modulus</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_operator</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + </p> +<p> + <span class="bold"><strong>Examples:</strong></span> + </p> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_modulus</span><span class="special"><</span><span class="identifier">Lhs</span><span class="special">,</span> <span class="identifier">Rhs</span><span class="special">,</span> <span class="identifier">Ret</span><span class="special">>::</span><span class="identifier">value_type</span></code> is the type <code class="computeroutput"><span class="keyword">bool</span></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_modulus</span><span class="special"><</span><span class="identifier">Lhs</span><span class="special">,</span> <span class="identifier">Rhs</span><span class="special">,</span> <span class="identifier">Ret</span><span class="special">>::</span><span class="identifier">value</span></code> is a <code class="computeroutput"><span class="keyword">bool</span></code> + integral constant expression. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_modulus</span><span class="special"><</span><span class="keyword">int</span><span class="special">>::</span><span class="identifier">value</span></code> is a <code class="computeroutput"><span class="keyword">bool</span></code> + integral constant expression that evaluates to <code class="computeroutput"><span class="keyword">true</span></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_modulus</span><span class="special"><</span><span class="keyword">long</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_modulus</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_modulus</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="keyword">long</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_modulus</span><span class="special"><</span><span class="keyword">const</span> <span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">>::</span><span class="identifier">value</span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_modulus</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>. + </p></blockquote></div> +<p> + <span class="bold"><strong>See also:</strong></span> <a class="link" href="../category/value_traits/operators.html" title="Operator Type Traits">Operator + Type Traits</a> + </p> +<p> + <span class="bold"><strong>Limitation:</strong></span> + </p> +<div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"> + Requires a compiler with working SFINAE. + </li></ul></div> +<p> + <span class="bold"><strong>Known issues:</strong></span> + </p> +<div class="itemizedlist"><ul class="itemizedlist" type="disc"> +<li class="listitem"> + This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">%</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">%</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">Lhs</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_modulus</span><span class="special"><</span><span class="identifier">Lhs</span><span class="special">></span></code> + will produce a compiler error. For this reason <code class="computeroutput"><span class="identifier">has_modulus</span></code> + cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">%</span></code> + or not. +<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">%(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&);</span> <span class="special">};</span> +<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_modulus</span><span class="special"><</span><span class="identifier">A</span><span class="special">>::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator%(const A&) is private</span> +</pre> + </li> +<li class="listitem"> + There is an issue if the operator exists only for type <code class="computeroutput"><span class="identifier">A</span></code> and <code class="computeroutput"><span class="identifier">B</span></code> + is convertible to <code class="computeroutput"><span class="identifier">A</span></code>. + In this case, the compiler will report an ambiguous overload. +<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span> +<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">%(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&,</span> <span class="keyword">const</span> <span class="identifier">A</span><span class="special">&);</span> +<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span> +<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_modulus</span><span class="special"><</span><span class="identifier">A</span><span class="special">>::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine</span> +<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_modulus</span><span class="special"><</span><span class="identifier">B</span><span class="special">>::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambiguous overload</span> +</pre> + </li> +<li class="listitem"> + There is an issue when applying this trait to template classes. If <code class="computeroutput"><span class="keyword">operator</span><span class="special">%</span></code> + is defined but does not bind for a given template type, it is still detected + by the trait which returns <code class="computeroutput"><span class="keyword">true</span></code> + instead of <code class="computeroutput"><span class="keyword">false</span></code>. Example: + +<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_modulus</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span> +<span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">iostream</span><span class="special">></span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">contains</span> <span class="special">{</span> <span class="identifier">T</span> <span class="identifier">data</span><span class="special">;</span> <span class="special">};</span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">%(</span><span class="keyword">const</span> <span class="identifier">contains</span><span class="special"><</span><span class="identifier">T</span><span class="special">></span> <span class="special">&</span><span class="identifier">lhs</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">contains</span><span class="special"><</span><span class="identifier">T</span><span class="special">></span> <span class="special">&</span><span class="identifier">rhs</span><span class="special">)</span> <span class="special">{</span> + <span class="keyword">return</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">,</span> <span class="identifier">rhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">);</span> +<span class="special">}</span> + +<span class="keyword">class</span> <span class="identifier">bad</span> <span class="special">{</span> <span class="special">};</span> +<span class="keyword">class</span> <span class="identifier">good</span> <span class="special">{</span> <span class="special">};</span> +<span class="keyword">bool</span> <span class="identifier">f</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">good</span><span class="special">&,</span> <span class="keyword">const</span> <span class="identifier">good</span><span class="special">&)</span> <span class="special">{</span> <span class="special">}</span> + +<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span> <span class="special">{</span> + <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special"><<</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">boolalpha</span><span class="special">;</span> + <span class="comment">// works fine for contains<good></span> + <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special"><<</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_modulus</span><span class="special"><</span> <span class="identifier">contains</span><span class="special"><</span> <span class="identifier">good</span> <span class="special">></span> <span class="special">>::</span><span class="identifier">value</span><span class="special"><<</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true</span> + <span class="identifier">contains</span><span class="special"><</span><span class="identifier">good</span><span class="special">></span> <span class="identifier">g</span><span class="special">;</span> + <span class="identifier">g</span><span class="special">%</span><span class="identifier">g</span><span class="special">;</span> <span class="comment">// ok</span> + <span class="comment">// does not work for contains<bad></span> + <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special"><<</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_modulus</span><span class="special"><</span> <span class="identifier">contains</span><span class="special"><</span> <span class="identifier">bad</span> <span class="special">></span> <span class="special">>::</span><span class="identifier">value</span><span class="special"><<</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true, should be false</span> + <span class="identifier">contains</span><span class="special"><</span><span class="identifier">bad</span><span class="special">></span> <span class="identifier">b</span><span class="special">;</span> + <span class="identifier">b</span><span class="special">%</span><span class="identifier">b</span><span class="special">;</span> <span class="comment">// compile time error</span> + <span class="keyword">return</span> <span class="number">0</span><span class="special">;</span> +<span class="special">}</span> +</pre> + </li> +<li class="listitem"> + <code class="computeroutput"><span class="keyword">volatile</span></code> qualifier is not + properly handled and would lead to undefined behavior + </li> +</ul></div> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="has_minus_assign.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="has_modulus_assign.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/reference/has_modulus_assign.html b/libs/type_traits/doc/html/boost_typetraits/reference/has_modulus_assign.html new file mode 100644 index 0000000000..fb98bec004 --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/reference/has_modulus_assign.html @@ -0,0 +1,191 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>has_modulus_assign</title> +<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../reference.html" title="Alphabetical Reference"> +<link rel="prev" href="has_modulus.html" title="has_modulus"> +<link rel="next" href="has_multiplies.html" title="has_multiplies"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td> +<td align="center"><a href="../../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="has_modulus.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="has_multiplies.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h3 class="title"> +<a name="boost_typetraits.reference.has_modulus_assign"></a><a class="link" href="has_modulus_assign.html" title="has_modulus_assign">has_modulus_assign</a> +</h3></div></div></div> +<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">Lhs</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Rhs</span><span class="special">=</span><span class="identifier">Lhs</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Ret</span><span class="special">=</span><span class="identifier">dont_care</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">has_modulus_assign</span> <span class="special">:</span> <span class="keyword">public</span> <em class="replaceable"><code><a class="link" href="integral_constant.html" title="integral_constant">true_type</a>-or-<a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code></em> <span class="special">{};</span> +</pre> +<p> + <span class="bold"><strong>Inherits:</strong></span> If (i) <code class="computeroutput"><span class="identifier">lhs</span></code> + of type <code class="computeroutput"><span class="identifier">Lhs</span></code> and <code class="computeroutput"><span class="identifier">rhs</span></code> of type <code class="computeroutput"><span class="identifier">Rhs</span></code> + can be used in expression <code class="computeroutput"><span class="identifier">lhs</span><span class="special">%=</span><span class="identifier">rhs</span></code>, + and (ii) <code class="computeroutput"><span class="identifier">Ret</span><span class="special">=</span><span class="identifier">dont_care</span></code> or the result of expression + <code class="computeroutput"><span class="identifier">lhs</span><span class="special">%=</span><span class="identifier">rhs</span></code> is convertible to <code class="computeroutput"><span class="identifier">Ret</span></code> + then inherits from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>, + otherwise inherits from <a class="link" href="integral_constant.html" title="integral_constant">false_type</a>. + </p> +<p> + The default behaviour (<code class="computeroutput"><span class="identifier">Ret</span><span class="special">=</span><span class="identifier">dont_care</span></code>) + is to not check for the return value of binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">%=</span></code>. If <code class="computeroutput"><span class="identifier">Ret</span></code> + is different from the default <code class="computeroutput"><span class="identifier">dont_care</span></code> + type, the return value is checked to be convertible to <code class="computeroutput"><span class="identifier">Ret</span></code>. + Convertible to <code class="computeroutput"><span class="identifier">Ret</span></code> means + that the return value of the operator can be used as argument to a function + expecting <code class="computeroutput"><span class="identifier">Ret</span></code>: +</p> +<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">Ret</span><span class="special">);</span> +<span class="identifier">Lhs</span> <span class="identifier">lhs</span><span class="special">;</span> +<span class="identifier">Rhs</span> <span class="identifier">rhs</span><span class="special">;</span> +<span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">%=</span><span class="identifier">rhs</span><span class="special">);</span> <span class="comment">// is valid if has_modulus_assign<Lhs, Rhs, Ret>::value==true</span> +</pre> +<p> + If <code class="computeroutput"><span class="identifier">Ret</span><span class="special">=</span><span class="keyword">void</span></code>, the return type is checked to be exactly + <code class="computeroutput"><span class="keyword">void</span></code>. + </p> +<p> + <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"><span class="preprocessor">#include</span> + <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_modulus_assign</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_operator</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + </p> +<p> + <span class="bold"><strong>Examples:</strong></span> + </p> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_modulus_assign</span><span class="special"><</span><span class="identifier">Lhs</span><span class="special">,</span> <span class="identifier">Rhs</span><span class="special">,</span> <span class="identifier">Ret</span><span class="special">>::</span><span class="identifier">value_type</span></code> is the type <code class="computeroutput"><span class="keyword">bool</span></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_modulus_assign</span><span class="special"><</span><span class="identifier">Lhs</span><span class="special">,</span> <span class="identifier">Rhs</span><span class="special">,</span> <span class="identifier">Ret</span><span class="special">>::</span><span class="identifier">value</span></code> is a <code class="computeroutput"><span class="keyword">bool</span></code> + integral constant expression. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_modulus_assign</span><span class="special"><</span><span class="keyword">int</span><span class="special">>::</span><span class="identifier">value</span></code> is a <code class="computeroutput"><span class="keyword">bool</span></code> + integral constant expression that evaluates to <code class="computeroutput"><span class="keyword">true</span></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_modulus_assign</span><span class="special"><</span><span class="keyword">long</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_modulus_assign</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_modulus_assign</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="keyword">long</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_modulus_assign</span><span class="special"><</span><span class="keyword">const</span> <span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">>::</span><span class="identifier">value</span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_modulus_assign</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>. + </p></blockquote></div> +<p> + <span class="bold"><strong>See also:</strong></span> <a class="link" href="../category/value_traits/operators.html" title="Operator Type Traits">Operator + Type Traits</a> + </p> +<p> + <span class="bold"><strong>Limitation:</strong></span> + </p> +<div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"> + Requires a compiler with working SFINAE. + </li></ul></div> +<p> + <span class="bold"><strong>Known issues:</strong></span> + </p> +<div class="itemizedlist"><ul class="itemizedlist" type="disc"> +<li class="listitem"> + This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">%=</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">%=</span></code> + is defined as a private member of <code class="computeroutput"><span class="identifier">Lhs</span></code> + then instantiating <code class="computeroutput"><span class="identifier">has_modulus_assign</span><span class="special"><</span><span class="identifier">Lhs</span><span class="special">></span></code> will produce a compiler error. For + this reason <code class="computeroutput"><span class="identifier">has_modulus_assign</span></code> + cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">%=</span></code> + or not. +<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">%=(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&);</span> <span class="special">};</span> +<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_modulus_assign</span><span class="special"><</span><span class="identifier">A</span><span class="special">>::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator%=(const A&) is private</span> +</pre> + </li> +<li class="listitem"> + There is an issue if the operator exists only for type <code class="computeroutput"><span class="identifier">A</span></code> and <code class="computeroutput"><span class="identifier">B</span></code> + is convertible to <code class="computeroutput"><span class="identifier">A</span></code>. + In this case, the compiler will report an ambiguous overload. +<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span> +<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">%=(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&,</span> <span class="keyword">const</span> <span class="identifier">A</span><span class="special">&);</span> +<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span> +<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_modulus_assign</span><span class="special"><</span><span class="identifier">A</span><span class="special">>::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine</span> +<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_modulus_assign</span><span class="special"><</span><span class="identifier">B</span><span class="special">>::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambiguous overload</span> +</pre> + </li> +<li class="listitem"> + There is an issue when applying this trait to template classes. If <code class="computeroutput"><span class="keyword">operator</span><span class="special">%=</span></code> + is defined but does not bind for a given template type, it is still detected + by the trait which returns <code class="computeroutput"><span class="keyword">true</span></code> + instead of <code class="computeroutput"><span class="keyword">false</span></code>. Example: + +<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_modulus_assign</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span> +<span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">iostream</span><span class="special">></span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">contains</span> <span class="special">{</span> <span class="identifier">T</span> <span class="identifier">data</span><span class="special">;</span> <span class="special">};</span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">%=(</span><span class="keyword">const</span> <span class="identifier">contains</span><span class="special"><</span><span class="identifier">T</span><span class="special">></span> <span class="special">&</span><span class="identifier">lhs</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">contains</span><span class="special"><</span><span class="identifier">T</span><span class="special">></span> <span class="special">&</span><span class="identifier">rhs</span><span class="special">)</span> <span class="special">{</span> + <span class="keyword">return</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">,</span> <span class="identifier">rhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">);</span> +<span class="special">}</span> + +<span class="keyword">class</span> <span class="identifier">bad</span> <span class="special">{</span> <span class="special">};</span> +<span class="keyword">class</span> <span class="identifier">good</span> <span class="special">{</span> <span class="special">};</span> +<span class="keyword">bool</span> <span class="identifier">f</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">good</span><span class="special">&,</span> <span class="keyword">const</span> <span class="identifier">good</span><span class="special">&)</span> <span class="special">{</span> <span class="special">}</span> + +<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span> <span class="special">{</span> + <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special"><<</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">boolalpha</span><span class="special">;</span> + <span class="comment">// works fine for contains<good></span> + <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special"><<</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_modulus_assign</span><span class="special"><</span> <span class="identifier">contains</span><span class="special"><</span> <span class="identifier">good</span> <span class="special">></span> <span class="special">>::</span><span class="identifier">value</span><span class="special"><<</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true</span> + <span class="identifier">contains</span><span class="special"><</span><span class="identifier">good</span><span class="special">></span> <span class="identifier">g</span><span class="special">;</span> + <span class="identifier">g</span><span class="special">%=</span><span class="identifier">g</span><span class="special">;</span> <span class="comment">// ok</span> + <span class="comment">// does not work for contains<bad></span> + <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special"><<</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_modulus_assign</span><span class="special"><</span> <span class="identifier">contains</span><span class="special"><</span> <span class="identifier">bad</span> <span class="special">></span> <span class="special">>::</span><span class="identifier">value</span><span class="special"><<</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true, should be false</span> + <span class="identifier">contains</span><span class="special"><</span><span class="identifier">bad</span><span class="special">></span> <span class="identifier">b</span><span class="special">;</span> + <span class="identifier">b</span><span class="special">%=</span><span class="identifier">b</span><span class="special">;</span> <span class="comment">// compile time error</span> + <span class="keyword">return</span> <span class="number">0</span><span class="special">;</span> +<span class="special">}</span> +</pre> + </li> +<li class="listitem"> + <code class="computeroutput"><span class="keyword">volatile</span></code> qualifier is not + properly handled and would lead to undefined behavior + </li> +</ul></div> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="has_modulus.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="has_multiplies.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/reference/has_multiplies.html b/libs/type_traits/doc/html/boost_typetraits/reference/has_multiplies.html new file mode 100644 index 0000000000..76bbb677ba --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/reference/has_multiplies.html @@ -0,0 +1,196 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>has_multiplies</title> +<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../reference.html" title="Alphabetical Reference"> +<link rel="prev" href="has_modulus_assign.html" title="has_modulus_assign"> +<link rel="next" href="has_multiplies_assign.html" title="has_multiplies_assign"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td> +<td align="center"><a href="../../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="has_modulus_assign.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="has_multiplies_assign.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h3 class="title"> +<a name="boost_typetraits.reference.has_multiplies"></a><a class="link" href="has_multiplies.html" title="has_multiplies">has_multiplies</a> +</h3></div></div></div> +<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">Lhs</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Rhs</span><span class="special">=</span><span class="identifier">Lhs</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Ret</span><span class="special">=</span><span class="identifier">dont_care</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">has_multiplies</span> <span class="special">:</span> <span class="keyword">public</span> <em class="replaceable"><code><a class="link" href="integral_constant.html" title="integral_constant">true_type</a>-or-<a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code></em> <span class="special">{};</span> +</pre> +<p> + <span class="bold"><strong>Inherits:</strong></span> If (i) <code class="computeroutput"><span class="identifier">lhs</span></code> + of type <code class="computeroutput"><span class="identifier">Lhs</span></code> and <code class="computeroutput"><span class="identifier">rhs</span></code> of type <code class="computeroutput"><span class="identifier">Rhs</span></code> + can be used in expression <code class="computeroutput"><span class="identifier">lhs</span><span class="special">*</span><span class="identifier">rhs</span></code>, and + (ii) <code class="computeroutput"><span class="identifier">Ret</span><span class="special">=</span><span class="identifier">dont_care</span></code> or the result of expression + <code class="computeroutput"><span class="identifier">lhs</span><span class="special">*</span><span class="identifier">rhs</span></code> is convertible to <code class="computeroutput"><span class="identifier">Ret</span></code> + then inherits from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>, + otherwise inherits from <a class="link" href="integral_constant.html" title="integral_constant">false_type</a>. + </p> +<p> + The default behaviour (<code class="computeroutput"><span class="identifier">Ret</span><span class="special">=</span><span class="identifier">dont_care</span></code>) + is to not check for the return value of binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">*</span></code>. If <code class="computeroutput"><span class="identifier">Ret</span></code> + is different from the default <code class="computeroutput"><span class="identifier">dont_care</span></code> + type, the return value is checked to be convertible to <code class="computeroutput"><span class="identifier">Ret</span></code>. + Convertible to <code class="computeroutput"><span class="identifier">Ret</span></code> means + that the return value of the operator can be used as argument to a function + expecting <code class="computeroutput"><span class="identifier">Ret</span></code>: +</p> +<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">Ret</span><span class="special">);</span> +<span class="identifier">Lhs</span> <span class="identifier">lhs</span><span class="special">;</span> +<span class="identifier">Rhs</span> <span class="identifier">rhs</span><span class="special">;</span> +<span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">*</span><span class="identifier">rhs</span><span class="special">);</span> <span class="comment">// is valid if has_multiplies<Lhs, Rhs, Ret>::value==true</span> +</pre> +<p> + If <code class="computeroutput"><span class="identifier">Ret</span><span class="special">=</span><span class="keyword">void</span></code>, the return type is checked to be exactly + <code class="computeroutput"><span class="keyword">void</span></code>. + </p> +<p> + <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"><span class="preprocessor">#include</span> + <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_multiplies</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_operator</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + </p> +<p> + <span class="bold"><strong>Examples:</strong></span> + </p> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_multiplies</span><span class="special"><</span><span class="identifier">Lhs</span><span class="special">,</span> <span class="identifier">Rhs</span><span class="special">,</span> <span class="identifier">Ret</span><span class="special">>::</span><span class="identifier">value_type</span></code> is the type <code class="computeroutput"><span class="keyword">bool</span></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_multiplies</span><span class="special"><</span><span class="identifier">Lhs</span><span class="special">,</span> <span class="identifier">Rhs</span><span class="special">,</span> <span class="identifier">Ret</span><span class="special">>::</span><span class="identifier">value</span></code> is a <code class="computeroutput"><span class="keyword">bool</span></code> + integral constant expression. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_multiplies</span><span class="special"><</span><span class="keyword">int</span><span class="special">>::</span><span class="identifier">value</span></code> is a <code class="computeroutput"><span class="keyword">bool</span></code> + integral constant expression that evaluates to <code class="computeroutput"><span class="keyword">true</span></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_multiplies</span><span class="special"><</span><span class="keyword">long</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_multiplies</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_multiplies</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="keyword">long</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_multiplies</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">double</span><span class="special">></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_multiplies</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">int</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_multiplies</span><span class="special"><</span><span class="keyword">const</span> <span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">>::</span><span class="identifier">value</span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_multiplies</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>. + </p></blockquote></div> +<p> + <span class="bold"><strong>See also:</strong></span> <a class="link" href="../category/value_traits/operators.html" title="Operator Type Traits">Operator + Type Traits</a> + </p> +<p> + <span class="bold"><strong>Limitation:</strong></span> + </p> +<div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"> + Requires a compiler with working SFINAE. + </li></ul></div> +<p> + <span class="bold"><strong>Known issues:</strong></span> + </p> +<div class="itemizedlist"><ul class="itemizedlist" type="disc"> +<li class="listitem"> + This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">*</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">*</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">Lhs</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_multiplies</span><span class="special"><</span><span class="identifier">Lhs</span><span class="special">></span></code> + will produce a compiler error. For this reason <code class="computeroutput"><span class="identifier">has_multiplies</span></code> + cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">*</span></code> + or not. +<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">*(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&);</span> <span class="special">};</span> +<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_multiplies</span><span class="special"><</span><span class="identifier">A</span><span class="special">>::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator*(const A&) is private</span> +</pre> + </li> +<li class="listitem"> + There is an issue if the operator exists only for type <code class="computeroutput"><span class="identifier">A</span></code> and <code class="computeroutput"><span class="identifier">B</span></code> + is convertible to <code class="computeroutput"><span class="identifier">A</span></code>. + In this case, the compiler will report an ambiguous overload. +<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span> +<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">*(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&,</span> <span class="keyword">const</span> <span class="identifier">A</span><span class="special">&);</span> +<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span> +<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_multiplies</span><span class="special"><</span><span class="identifier">A</span><span class="special">>::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine</span> +<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_multiplies</span><span class="special"><</span><span class="identifier">B</span><span class="special">>::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambiguous overload</span> +</pre> + </li> +<li class="listitem"> + There is an issue when applying this trait to template classes. If <code class="computeroutput"><span class="keyword">operator</span><span class="special">*</span></code> + is defined but does not bind for a given template type, it is still detected + by the trait which returns <code class="computeroutput"><span class="keyword">true</span></code> + instead of <code class="computeroutput"><span class="keyword">false</span></code>. Example: + +<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_multiplies</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span> +<span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">iostream</span><span class="special">></span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">contains</span> <span class="special">{</span> <span class="identifier">T</span> <span class="identifier">data</span><span class="special">;</span> <span class="special">};</span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">*(</span><span class="keyword">const</span> <span class="identifier">contains</span><span class="special"><</span><span class="identifier">T</span><span class="special">></span> <span class="special">&</span><span class="identifier">lhs</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">contains</span><span class="special"><</span><span class="identifier">T</span><span class="special">></span> <span class="special">&</span><span class="identifier">rhs</span><span class="special">)</span> <span class="special">{</span> + <span class="keyword">return</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">,</span> <span class="identifier">rhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">);</span> +<span class="special">}</span> + +<span class="keyword">class</span> <span class="identifier">bad</span> <span class="special">{</span> <span class="special">};</span> +<span class="keyword">class</span> <span class="identifier">good</span> <span class="special">{</span> <span class="special">};</span> +<span class="keyword">bool</span> <span class="identifier">f</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">good</span><span class="special">&,</span> <span class="keyword">const</span> <span class="identifier">good</span><span class="special">&)</span> <span class="special">{</span> <span class="special">}</span> + +<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span> <span class="special">{</span> + <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special"><<</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">boolalpha</span><span class="special">;</span> + <span class="comment">// works fine for contains<good></span> + <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special"><<</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_multiplies</span><span class="special"><</span> <span class="identifier">contains</span><span class="special"><</span> <span class="identifier">good</span> <span class="special">></span> <span class="special">>::</span><span class="identifier">value</span><span class="special"><<</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true</span> + <span class="identifier">contains</span><span class="special"><</span><span class="identifier">good</span><span class="special">></span> <span class="identifier">g</span><span class="special">;</span> + <span class="identifier">g</span><span class="special">*</span><span class="identifier">g</span><span class="special">;</span> <span class="comment">// ok</span> + <span class="comment">// does not work for contains<bad></span> + <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special"><<</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_multiplies</span><span class="special"><</span> <span class="identifier">contains</span><span class="special"><</span> <span class="identifier">bad</span> <span class="special">></span> <span class="special">>::</span><span class="identifier">value</span><span class="special"><<</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true, should be false</span> + <span class="identifier">contains</span><span class="special"><</span><span class="identifier">bad</span><span class="special">></span> <span class="identifier">b</span><span class="special">;</span> + <span class="identifier">b</span><span class="special">*</span><span class="identifier">b</span><span class="special">;</span> <span class="comment">// compile time error</span> + <span class="keyword">return</span> <span class="number">0</span><span class="special">;</span> +<span class="special">}</span> +</pre> + </li> +<li class="listitem"> + <code class="computeroutput"><span class="keyword">volatile</span></code> qualifier is not + properly handled and would lead to undefined behavior + </li> +</ul></div> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="has_modulus_assign.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="has_multiplies_assign.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/reference/has_multiplies_assign.html b/libs/type_traits/doc/html/boost_typetraits/reference/has_multiplies_assign.html new file mode 100644 index 0000000000..e9ada4da09 --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/reference/has_multiplies_assign.html @@ -0,0 +1,198 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>has_multiplies_assign</title> +<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../reference.html" title="Alphabetical Reference"> +<link rel="prev" href="has_multiplies.html" title="has_multiplies"> +<link rel="next" href="has_negate.html" title="has_negate"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td> +<td align="center"><a href="../../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="has_multiplies.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="has_negate.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h3 class="title"> +<a name="boost_typetraits.reference.has_multiplies_assign"></a><a class="link" href="has_multiplies_assign.html" title="has_multiplies_assign">has_multiplies_assign</a> +</h3></div></div></div> +<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">Lhs</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Rhs</span><span class="special">=</span><span class="identifier">Lhs</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Ret</span><span class="special">=</span><span class="identifier">dont_care</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">has_multiplies_assign</span> <span class="special">:</span> <span class="keyword">public</span> <em class="replaceable"><code><a class="link" href="integral_constant.html" title="integral_constant">true_type</a>-or-<a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code></em> <span class="special">{};</span> +</pre> +<p> + <span class="bold"><strong>Inherits:</strong></span> If (i) <code class="computeroutput"><span class="identifier">lhs</span></code> + of type <code class="computeroutput"><span class="identifier">Lhs</span></code> and <code class="computeroutput"><span class="identifier">rhs</span></code> of type <code class="computeroutput"><span class="identifier">Rhs</span></code> + can be used in expression <code class="computeroutput"><span class="identifier">lhs</span><span class="special">*=</span><span class="identifier">rhs</span></code>, + and (ii) <code class="computeroutput"><span class="identifier">Ret</span><span class="special">=</span><span class="identifier">dont_care</span></code> or the result of expression + <code class="computeroutput"><span class="identifier">lhs</span><span class="special">*=</span><span class="identifier">rhs</span></code> is convertible to <code class="computeroutput"><span class="identifier">Ret</span></code> + then inherits from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>, + otherwise inherits from <a class="link" href="integral_constant.html" title="integral_constant">false_type</a>. + </p> +<p> + The default behaviour (<code class="computeroutput"><span class="identifier">Ret</span><span class="special">=</span><span class="identifier">dont_care</span></code>) + is to not check for the return value of binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">*=</span></code>. If <code class="computeroutput"><span class="identifier">Ret</span></code> + is different from the default <code class="computeroutput"><span class="identifier">dont_care</span></code> + type, the return value is checked to be convertible to <code class="computeroutput"><span class="identifier">Ret</span></code>. + Convertible to <code class="computeroutput"><span class="identifier">Ret</span></code> means + that the return value of the operator can be used as argument to a function + expecting <code class="computeroutput"><span class="identifier">Ret</span></code>: +</p> +<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">Ret</span><span class="special">);</span> +<span class="identifier">Lhs</span> <span class="identifier">lhs</span><span class="special">;</span> +<span class="identifier">Rhs</span> <span class="identifier">rhs</span><span class="special">;</span> +<span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">*=</span><span class="identifier">rhs</span><span class="special">);</span> <span class="comment">// is valid if has_multiplies_assign<Lhs, Rhs, Ret>::value==true</span> +</pre> +<p> + If <code class="computeroutput"><span class="identifier">Ret</span><span class="special">=</span><span class="keyword">void</span></code>, the return type is checked to be exactly + <code class="computeroutput"><span class="keyword">void</span></code>. + </p> +<p> + <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"><span class="preprocessor">#include</span> + <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_multiplies_assign</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_operator</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + </p> +<p> + <span class="bold"><strong>Examples:</strong></span> + </p> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_multiplies_assign</span><span class="special"><</span><span class="identifier">Lhs</span><span class="special">,</span> <span class="identifier">Rhs</span><span class="special">,</span> <span class="identifier">Ret</span><span class="special">>::</span><span class="identifier">value_type</span></code> is the type <code class="computeroutput"><span class="keyword">bool</span></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_multiplies_assign</span><span class="special"><</span><span class="identifier">Lhs</span><span class="special">,</span> <span class="identifier">Rhs</span><span class="special">,</span> <span class="identifier">Ret</span><span class="special">>::</span><span class="identifier">value</span></code> is a <code class="computeroutput"><span class="keyword">bool</span></code> + integral constant expression. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_multiplies_assign</span><span class="special"><</span><span class="keyword">int</span><span class="special">>::</span><span class="identifier">value</span></code> is a <code class="computeroutput"><span class="keyword">bool</span></code> + integral constant expression that evaluates to <code class="computeroutput"><span class="keyword">true</span></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_multiplies_assign</span><span class="special"><</span><span class="keyword">long</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_multiplies_assign</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_multiplies_assign</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="keyword">long</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_multiplies_assign</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">double</span><span class="special">></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_multiplies_assign</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">int</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_multiplies_assign</span><span class="special"><</span><span class="keyword">const</span> <span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">>::</span><span class="identifier">value</span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_multiplies_assign</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>. + </p></blockquote></div> +<p> + <span class="bold"><strong>See also:</strong></span> <a class="link" href="../category/value_traits/operators.html" title="Operator Type Traits">Operator + Type Traits</a> + </p> +<p> + <span class="bold"><strong>Limitation:</strong></span> + </p> +<div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"> + Requires a compiler with working SFINAE. + </li></ul></div> +<p> + <span class="bold"><strong>Known issues:</strong></span> + </p> +<div class="itemizedlist"><ul class="itemizedlist" type="disc"> +<li class="listitem"> + This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">*=</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">*=</span></code> + is defined as a private member of <code class="computeroutput"><span class="identifier">Lhs</span></code> + then instantiating <code class="computeroutput"><span class="identifier">has_multiplies_assign</span><span class="special"><</span><span class="identifier">Lhs</span><span class="special">></span></code> will produce a compiler error. For + this reason <code class="computeroutput"><span class="identifier">has_multiplies_assign</span></code> + cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">*=</span></code> + or not. +<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">*=(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&);</span> <span class="special">};</span> +<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_multiplies_assign</span><span class="special"><</span><span class="identifier">A</span><span class="special">>::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator*=(const A&) is private</span> +</pre> + </li> +<li class="listitem"> + There is an issue if the operator exists only for type <code class="computeroutput"><span class="identifier">A</span></code> and <code class="computeroutput"><span class="identifier">B</span></code> + is convertible to <code class="computeroutput"><span class="identifier">A</span></code>. + In this case, the compiler will report an ambiguous overload. +<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span> +<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">*=(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&,</span> <span class="keyword">const</span> <span class="identifier">A</span><span class="special">&);</span> +<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span> +<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_multiplies_assign</span><span class="special"><</span><span class="identifier">A</span><span class="special">>::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine</span> +<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_multiplies_assign</span><span class="special"><</span><span class="identifier">B</span><span class="special">>::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambiguous overload</span> +</pre> + </li> +<li class="listitem"> + There is an issue when applying this trait to template classes. If <code class="computeroutput"><span class="keyword">operator</span><span class="special">*=</span></code> + is defined but does not bind for a given template type, it is still detected + by the trait which returns <code class="computeroutput"><span class="keyword">true</span></code> + instead of <code class="computeroutput"><span class="keyword">false</span></code>. Example: + +<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_multiplies_assign</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span> +<span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">iostream</span><span class="special">></span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">contains</span> <span class="special">{</span> <span class="identifier">T</span> <span class="identifier">data</span><span class="special">;</span> <span class="special">};</span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">*=(</span><span class="keyword">const</span> <span class="identifier">contains</span><span class="special"><</span><span class="identifier">T</span><span class="special">></span> <span class="special">&</span><span class="identifier">lhs</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">contains</span><span class="special"><</span><span class="identifier">T</span><span class="special">></span> <span class="special">&</span><span class="identifier">rhs</span><span class="special">)</span> <span class="special">{</span> + <span class="keyword">return</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">,</span> <span class="identifier">rhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">);</span> +<span class="special">}</span> + +<span class="keyword">class</span> <span class="identifier">bad</span> <span class="special">{</span> <span class="special">};</span> +<span class="keyword">class</span> <span class="identifier">good</span> <span class="special">{</span> <span class="special">};</span> +<span class="keyword">bool</span> <span class="identifier">f</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">good</span><span class="special">&,</span> <span class="keyword">const</span> <span class="identifier">good</span><span class="special">&)</span> <span class="special">{</span> <span class="special">}</span> + +<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span> <span class="special">{</span> + <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special"><<</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">boolalpha</span><span class="special">;</span> + <span class="comment">// works fine for contains<good></span> + <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special"><<</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_multiplies_assign</span><span class="special"><</span> <span class="identifier">contains</span><span class="special"><</span> <span class="identifier">good</span> <span class="special">></span> <span class="special">>::</span><span class="identifier">value</span><span class="special"><<</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true</span> + <span class="identifier">contains</span><span class="special"><</span><span class="identifier">good</span><span class="special">></span> <span class="identifier">g</span><span class="special">;</span> + <span class="identifier">g</span><span class="special">*=</span><span class="identifier">g</span><span class="special">;</span> <span class="comment">// ok</span> + <span class="comment">// does not work for contains<bad></span> + <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special"><<</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_multiplies_assign</span><span class="special"><</span> <span class="identifier">contains</span><span class="special"><</span> <span class="identifier">bad</span> <span class="special">></span> <span class="special">>::</span><span class="identifier">value</span><span class="special"><<</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true, should be false</span> + <span class="identifier">contains</span><span class="special"><</span><span class="identifier">bad</span><span class="special">></span> <span class="identifier">b</span><span class="special">;</span> + <span class="identifier">b</span><span class="special">*=</span><span class="identifier">b</span><span class="special">;</span> <span class="comment">// compile time error</span> + <span class="keyword">return</span> <span class="number">0</span><span class="special">;</span> +<span class="special">}</span> +</pre> + </li> +<li class="listitem"> + <code class="computeroutput"><span class="keyword">volatile</span></code> qualifier is not + properly handled and would lead to undefined behavior + </li> +</ul></div> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="has_multiplies.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="has_negate.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/reference/has_negate.html b/libs/type_traits/doc/html/boost_typetraits/reference/has_negate.html new file mode 100644 index 0000000000..d397534643 --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/reference/has_negate.html @@ -0,0 +1,195 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>has_negate</title> +<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../reference.html" title="Alphabetical Reference"> +<link rel="prev" href="has_multiplies_assign.html" title="has_multiplies_assign"> +<link rel="next" href="has_new_operator.html" title="has_new_operator"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td> +<td align="center"><a href="../../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="has_multiplies_assign.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="has_new_operator.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h3 class="title"> +<a name="boost_typetraits.reference.has_negate"></a><a class="link" href="has_negate.html" title="has_negate">has_negate</a> +</h3></div></div></div> +<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">Rhs</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Ret</span><span class="special">=</span><span class="identifier">dont_care</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">has_negate</span> <span class="special">:</span> <span class="keyword">public</span> <em class="replaceable"><code><a class="link" href="integral_constant.html" title="integral_constant">true_type</a>-or-<a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code></em> <span class="special">{};</span> +</pre> +<p> + <span class="bold"><strong>Inherits:</strong></span> If (i) <code class="computeroutput"><span class="identifier">rhs</span></code> + of type <code class="computeroutput"><span class="identifier">Rhs</span></code> can be used in + expression <code class="computeroutput"><span class="special">-</span><span class="identifier">rhs</span></code>, + and (ii) <code class="computeroutput"><span class="identifier">Ret</span><span class="special">=</span><span class="identifier">dont_care</span></code> or the result of expression + <code class="computeroutput"><span class="special">-</span><span class="identifier">rhs</span></code> + is convertible to <code class="computeroutput"><span class="identifier">Ret</span></code> then + inherits from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>, + otherwise inherits from <a class="link" href="integral_constant.html" title="integral_constant">false_type</a>. + </p> +<p> + The default behaviour (<code class="computeroutput"><span class="identifier">Ret</span><span class="special">=</span><span class="identifier">dont_care</span></code>) + is to not check for the return value of prefix <code class="computeroutput"><span class="keyword">operator</span><span class="special">-</span></code>. If <code class="computeroutput"><span class="identifier">Ret</span></code> + is different from the default <code class="computeroutput"><span class="identifier">dont_care</span></code> + type, the return value is checked to be convertible to <code class="computeroutput"><span class="identifier">Ret</span></code>. + Convertible to <code class="computeroutput"><span class="identifier">Ret</span></code> means + that the return value of the operator can be used as argument to a function + expecting <code class="computeroutput"><span class="identifier">Ret</span></code>: +</p> +<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">Ret</span><span class="special">);</span> +<span class="identifier">Rhs</span> <span class="identifier">rhs</span><span class="special">;</span> +<span class="identifier">f</span><span class="special">(-</span><span class="identifier">rhs</span><span class="special">);</span> <span class="comment">// is valid if has_negate<Rhs, Ret>::value==true</span> +</pre> +<p> + If <code class="computeroutput"><span class="identifier">Ret</span><span class="special">=</span><span class="keyword">void</span></code>, the return type is checked to be exactly + <code class="computeroutput"><span class="keyword">void</span></code>. + </p> +<p> + <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"><span class="preprocessor">#include</span> + <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_negate</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_operator</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + </p> +<p> + <span class="bold"><strong>Examples:</strong></span> + </p> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_negate</span><span class="special"><</span><span class="identifier">Rhs</span><span class="special">,</span> <span class="identifier">Ret</span><span class="special">>::</span><span class="identifier">value_type</span></code> is the type <code class="computeroutput"><span class="keyword">bool</span></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_negate</span><span class="special"><</span><span class="identifier">Rhs</span><span class="special">,</span> <span class="identifier">Ret</span><span class="special">>::</span><span class="identifier">value</span></code> is a <code class="computeroutput"><span class="keyword">bool</span></code> + integral constant expression. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_negate</span><span class="special"><</span><span class="keyword">int</span><span class="special">>::</span><span class="identifier">value</span></code> is a <code class="computeroutput"><span class="keyword">bool</span></code> + integral constant expression that evaluates to <code class="computeroutput"><span class="keyword">true</span></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_negate</span><span class="special"><</span><span class="keyword">long</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_negate</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_negate</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">long</span><span class="special">></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_negate</span><span class="special"><</span><span class="keyword">double</span><span class="special">,</span> <span class="keyword">double</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_negate</span><span class="special"><</span><span class="keyword">double</span><span class="special">,</span> <span class="keyword">int</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_negate</span><span class="special"><</span><span class="keyword">const</span> <span class="keyword">int</span><span class="special">></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_negate</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>. + </p></blockquote></div> +<p> + <span class="bold"><strong>See also:</strong></span> <a class="link" href="../category/value_traits/operators.html" title="Operator Type Traits">Operator + Type Traits</a> + </p> +<p> + <span class="bold"><strong>Limitation:</strong></span> + </p> +<div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"> + Requires a compiler with working SFINAE. + </li></ul></div> +<p> + <span class="bold"><strong>Known issues:</strong></span> + </p> +<div class="itemizedlist"><ul class="itemizedlist" type="disc"> +<li class="listitem"> + This trait cannot detect whether prefix <code class="computeroutput"><span class="keyword">operator</span><span class="special">-</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">-</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">Rhs</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_negate</span><span class="special"><</span><span class="identifier">Rhs</span><span class="special">></span></code> + will produce a compiler error. For this reason <code class="computeroutput"><span class="identifier">has_negate</span></code> + cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">-</span></code> + or not. +<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">-();</span> <span class="special">};</span> +<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_negate</span><span class="special"><</span><span class="identifier">A</span><span class="special">>::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator-() is private</span> +</pre> + </li> +<li class="listitem"> + There is an issue if the operator exists only for type <code class="computeroutput"><span class="identifier">A</span></code> and <code class="computeroutput"><span class="identifier">B</span></code> + is convertible to <code class="computeroutput"><span class="identifier">A</span></code>. + In this case, the compiler will report an ambiguous overload. +<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span> +<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">-(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&);</span> +<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span> +<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_negate</span><span class="special"><</span><span class="identifier">A</span><span class="special">>::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine</span> +<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_negate</span><span class="special"><</span><span class="identifier">B</span><span class="special">>::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambiguous overload</span> +</pre> + </li> +<li class="listitem"> + There is an issue when applying this trait to template classes. If <code class="computeroutput"><span class="keyword">operator</span><span class="special">-</span></code> + is defined but does not bind for a given template type, it is still detected + by the trait which returns <code class="computeroutput"><span class="keyword">true</span></code> + instead of <code class="computeroutput"><span class="keyword">false</span></code>. Example: + +<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_negate</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span> +<span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">iostream</span><span class="special">></span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">contains</span> <span class="special">{</span> <span class="identifier">T</span> <span class="identifier">data</span><span class="special">;</span> <span class="special">};</span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">-(</span><span class="keyword">const</span> <span class="identifier">contains</span><span class="special"><</span><span class="identifier">T</span><span class="special">></span> <span class="special">&</span><span class="identifier">rhs</span><span class="special">)</span> <span class="special">{</span> + <span class="keyword">return</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">rhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">);</span> +<span class="special">}</span> + +<span class="keyword">class</span> <span class="identifier">bad</span> <span class="special">{</span> <span class="special">};</span> +<span class="keyword">class</span> <span class="identifier">good</span> <span class="special">{</span> <span class="special">};</span> +<span class="keyword">bool</span> <span class="identifier">f</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">good</span><span class="special">&)</span> <span class="special">{</span> <span class="special">}</span> + +<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span> <span class="special">{</span> + <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special"><<</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">boolalpha</span><span class="special">;</span> + <span class="comment">// works fine for contains<good></span> + <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special"><<</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_negate</span><span class="special"><</span> <span class="identifier">contains</span><span class="special"><</span> <span class="identifier">good</span> <span class="special">></span> <span class="special">>::</span><span class="identifier">value</span><span class="special"><<</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true</span> + <span class="identifier">contains</span><span class="special"><</span><span class="identifier">good</span><span class="special">></span> <span class="identifier">g</span><span class="special">;</span> + <span class="special">-</span><span class="identifier">g</span><span class="special">;</span> <span class="comment">// ok</span> + <span class="comment">// does not work for contains<bad></span> + <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special"><<</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_negate</span><span class="special"><</span> <span class="identifier">contains</span><span class="special"><</span> <span class="identifier">bad</span> <span class="special">></span> <span class="special">>::</span><span class="identifier">value</span><span class="special"><<</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true, should be false</span> + <span class="identifier">contains</span><span class="special"><</span><span class="identifier">bad</span><span class="special">></span> <span class="identifier">b</span><span class="special">;</span> + <span class="special">-</span><span class="identifier">b</span><span class="special">;</span> <span class="comment">// compile time error</span> + <span class="keyword">return</span> <span class="number">0</span><span class="special">;</span> +<span class="special">}</span> +</pre> + </li> +<li class="listitem"> + <code class="computeroutput"><span class="keyword">volatile</span></code> qualifier is not + properly handled and would lead to undefined behavior + </li> +</ul></div> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="has_multiplies_assign.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="has_new_operator.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/reference/has_new_operator.html b/libs/type_traits/doc/html/boost_typetraits/reference/has_new_operator.html new file mode 100644 index 0000000000..fbf0939d4c --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/reference/has_new_operator.html @@ -0,0 +1,109 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>has_new_operator</title> +<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../reference.html" title="Alphabetical Reference"> +<link rel="prev" href="has_negate.html" title="has_negate"> +<link rel="next" href="has_not_equal_to.html" title="has_not_equal_to"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td> +<td align="center"><a href="../../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="has_negate.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="has_not_equal_to.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h3 class="title"> +<a name="boost_typetraits.reference.has_new_operator"></a><a class="link" href="has_new_operator.html" title="has_new_operator">has_new_operator</a> +</h3></div></div></div> +<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">has_new_operator</span> <span class="special">:</span> <span class="keyword">public</span> <em class="replaceable"><code><a class="link" href="integral_constant.html" title="integral_constant">true_type</a>-or-<a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code></em> <span class="special">{};</span> +</pre> +<p> + <span class="bold"><strong>Inherits:</strong></span> If T is a (possibly cv-qualified) + type with an overloaded new-operator then inherits from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>, + otherwise inherits from <a class="link" href="integral_constant.html" title="integral_constant">false_type</a>. + </p> +<p> + <span class="bold"><strong>Compiler Compatibility:</strong></span> Not usable with + compilers that do not support "substitution failure is not an error" + (in which case BOOST_NO_SFINAE will be defined), also known to be broken + with the Borland/Codegear compiler. + </p> +<p> + <span class="bold"><strong>C++ Standard Reference:</strong></span> 12.5. + </p> +<p> + <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"> <span class="preprocessor">#include</span> + <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_new_operator</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + </p> +<p> + <span class="bold"><strong>Examples:</strong></span> + </p> +<p> + Given: + </p> +<pre class="programlisting"><span class="keyword">class</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">void</span><span class="special">*</span> <span class="keyword">operator</span> <span class="keyword">new</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span><span class="special">);</span> <span class="special">};</span> +<span class="keyword">class</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">void</span><span class="special">*</span> <span class="keyword">operator</span> <span class="keyword">new</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">nothrow</span><span class="special">&);</span> <span class="special">};</span> +<span class="keyword">class</span> <span class="identifier">C</span> <span class="special">{</span> <span class="keyword">void</span><span class="special">*</span> <span class="keyword">operator</span> <span class="keyword">new</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span><span class="special">,</span> <span class="keyword">void</span><span class="special">*);</span> <span class="special">};</span> +<span class="keyword">class</span> <span class="identifier">D</span> <span class="special">{</span> <span class="keyword">void</span><span class="special">*</span> <span class="keyword">operator</span> <span class="keyword">new</span><span class="special">[](</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span><span class="special">);</span> <span class="special">};</span> +<span class="keyword">class</span> <span class="identifier">E</span> <span class="special">{</span> <span class="keyword">void</span><span class="special">*</span> <span class="keyword">operator</span> <span class="keyword">new</span><span class="special">[](</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">nothrow</span><span class="special">&);</span> <span class="special">};</span> +<span class="keyword">class</span> <span class="identifier">F</span> <span class="special">{</span> <span class="keyword">void</span><span class="special">*</span> <span class="keyword">operator</span> <span class="keyword">new</span><span class="special">[](</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span><span class="special">,</span> <span class="keyword">void</span><span class="special">*);</span> <span class="special">};</span> +</pre> +<p> + Then: + </p> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_new_operator</span><span class="special"><</span><span class="identifier">A</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_new_operator</span><span class="special"><</span><span class="identifier">B</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_new_operator</span><span class="special"><</span><span class="identifier">C</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_new_operator</span><span class="special"><</span><span class="identifier">D</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_new_operator</span><span class="special"><</span><span class="identifier">E</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_new_operator</span><span class="special"><</span><span class="identifier">F</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="has_negate.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="has_not_equal_to.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/reference/has_no_throw_def_cons.html b/libs/type_traits/doc/html/boost_typetraits/reference/has_no_throw_def_cons.html new file mode 100644 index 0000000000..0c30826491 --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/reference/has_no_throw_def_cons.html @@ -0,0 +1,50 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>has_nothrow_default_constructor</title> +<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../reference.html" title="Alphabetical Reference"> +<link rel="prev" href="has_nothrow_cp_cons.html" title="has_nothrow_copy_constructor"> +<link rel="next" href="has_plus.html" title="has_plus"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td> +<td align="center"><a href="../../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="has_nothrow_cp_cons.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="has_plus.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h3 class="title"> +<a name="boost_typetraits.reference.has_no_throw_def_cons"></a><a class="link" href="has_no_throw_def_cons.html" title="has_nothrow_default_constructor">has_nothrow_default_constructor</a> +</h3></div></div></div> +<p> + See <a class="link" href="has_nothrow_constructor.html" title="has_nothrow_constructor">has_nothrow_constructor</a>. + </p> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="has_nothrow_cp_cons.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="has_plus.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/reference/has_not_equal_to.html b/libs/type_traits/doc/html/boost_typetraits/reference/has_not_equal_to.html new file mode 100644 index 0000000000..91234d7fab --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/reference/has_not_equal_to.html @@ -0,0 +1,197 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>has_not_equal_to</title> +<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../reference.html" title="Alphabetical Reference"> +<link rel="prev" href="has_new_operator.html" title="has_new_operator"> +<link rel="next" href="has_nothrow_assign.html" title="has_nothrow_assign"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td> +<td align="center"><a href="../../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="has_new_operator.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="has_nothrow_assign.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h3 class="title"> +<a name="boost_typetraits.reference.has_not_equal_to"></a><a class="link" href="has_not_equal_to.html" title="has_not_equal_to">has_not_equal_to</a> +</h3></div></div></div> +<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">Lhs</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Rhs</span><span class="special">=</span><span class="identifier">Lhs</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Ret</span><span class="special">=</span><span class="identifier">dont_care</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">has_not_equal_to</span> <span class="special">:</span> <span class="keyword">public</span> <em class="replaceable"><code><a class="link" href="integral_constant.html" title="integral_constant">true_type</a>-or-<a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code></em> <span class="special">{};</span> +</pre> +<p> + <span class="bold"><strong>Inherits:</strong></span> If (i) <code class="computeroutput"><span class="identifier">lhs</span></code> + of type <code class="computeroutput"><span class="identifier">Lhs</span></code> and <code class="computeroutput"><span class="identifier">rhs</span></code> of type <code class="computeroutput"><span class="identifier">Rhs</span></code> + can be used in expression <code class="computeroutput"><span class="identifier">lhs</span><span class="special">!=</span><span class="identifier">rhs</span></code>, + and (ii) <code class="computeroutput"><span class="identifier">Ret</span><span class="special">=</span><span class="identifier">dont_care</span></code> or the result of expression + <code class="computeroutput"><span class="identifier">lhs</span><span class="special">!=</span><span class="identifier">rhs</span></code> is convertible to <code class="computeroutput"><span class="identifier">Ret</span></code> + then inherits from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>, + otherwise inherits from <a class="link" href="integral_constant.html" title="integral_constant">false_type</a>. + </p> +<p> + The default behaviour (<code class="computeroutput"><span class="identifier">Ret</span><span class="special">=</span><span class="identifier">dont_care</span></code>) + is to not check for the return value of binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">!=</span></code>. If <code class="computeroutput"><span class="identifier">Ret</span></code> + is different from the default <code class="computeroutput"><span class="identifier">dont_care</span></code> + type, the return value is checked to be convertible to <code class="computeroutput"><span class="identifier">Ret</span></code>. + Convertible to <code class="computeroutput"><span class="identifier">Ret</span></code> means + that the return value of the operator can be used as argument to a function + expecting <code class="computeroutput"><span class="identifier">Ret</span></code>: +</p> +<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">Ret</span><span class="special">);</span> +<span class="identifier">Lhs</span> <span class="identifier">lhs</span><span class="special">;</span> +<span class="identifier">Rhs</span> <span class="identifier">rhs</span><span class="special">;</span> +<span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">!=</span><span class="identifier">rhs</span><span class="special">);</span> <span class="comment">// is valid if has_not_equal_to<Lhs, Rhs, Ret>::value==true</span> +</pre> +<p> + If <code class="computeroutput"><span class="identifier">Ret</span><span class="special">=</span><span class="keyword">void</span></code>, the return type is checked to be exactly + <code class="computeroutput"><span class="keyword">void</span></code>. + </p> +<p> + <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"><span class="preprocessor">#include</span> + <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_not_equal_to</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_operator</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + </p> +<p> + <span class="bold"><strong>Examples:</strong></span> + </p> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_not_equal_to</span><span class="special"><</span><span class="identifier">Lhs</span><span class="special">,</span> <span class="identifier">Rhs</span><span class="special">,</span> <span class="identifier">Ret</span><span class="special">>::</span><span class="identifier">value_type</span></code> is the type <code class="computeroutput"><span class="keyword">bool</span></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_not_equal_to</span><span class="special"><</span><span class="identifier">Lhs</span><span class="special">,</span> <span class="identifier">Rhs</span><span class="special">,</span> <span class="identifier">Ret</span><span class="special">>::</span><span class="identifier">value</span></code> is a <code class="computeroutput"><span class="keyword">bool</span></code> + integral constant expression. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_not_equal_to</span><span class="special"><</span><span class="keyword">int</span><span class="special">>::</span><span class="identifier">value</span></code> is a <code class="computeroutput"><span class="keyword">bool</span></code> + integral constant expression that evaluates to <code class="computeroutput"><span class="keyword">true</span></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_not_equal_to</span><span class="special"><</span><span class="keyword">long</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_not_equal_to</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="keyword">bool</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_not_equal_to</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">bool</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_not_equal_to</span><span class="special"><</span><span class="keyword">const</span> <span class="keyword">int</span><span class="special">></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_not_equal_to</span><span class="special"><</span><span class="keyword">int</span><span class="special">*,</span> <span class="keyword">int</span><span class="special">></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_not_equal_to</span><span class="special"><</span><span class="keyword">int</span><span class="special">*,</span> <span class="keyword">double</span><span class="special">*></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_not_equal_to</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>. + </p></blockquote></div> +<p> + <span class="bold"><strong>See also:</strong></span> <a class="link" href="../category/value_traits/operators.html" title="Operator Type Traits">Operator + Type Traits</a> + </p> +<p> + <span class="bold"><strong>Limitation:</strong></span> + </p> +<div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"> + Requires a compiler with working SFINAE. + </li></ul></div> +<p> + <span class="bold"><strong>Known issues:</strong></span> + </p> +<div class="itemizedlist"><ul class="itemizedlist" type="disc"> +<li class="listitem"> + This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">!=</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">!=</span></code> + is defined as a private member of <code class="computeroutput"><span class="identifier">Lhs</span></code> + then instantiating <code class="computeroutput"><span class="identifier">has_not_equal_to</span><span class="special"><</span><span class="identifier">Lhs</span><span class="special">></span></code> will produce a compiler error. For + this reason <code class="computeroutput"><span class="identifier">has_not_equal_to</span></code> + cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">!=</span></code> + or not. +<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">!=(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&);</span> <span class="special">};</span> +<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_not_equal_to</span><span class="special"><</span><span class="identifier">A</span><span class="special">>::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator!=(const A&) is private</span> +</pre> + </li> +<li class="listitem"> + There is an issue if the operator exists only for type <code class="computeroutput"><span class="identifier">A</span></code> and <code class="computeroutput"><span class="identifier">B</span></code> + is convertible to <code class="computeroutput"><span class="identifier">A</span></code>. + In this case, the compiler will report an ambiguous overload. +<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span> +<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">!=(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&,</span> <span class="keyword">const</span> <span class="identifier">A</span><span class="special">&);</span> +<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span> +<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_not_equal_to</span><span class="special"><</span><span class="identifier">A</span><span class="special">>::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine</span> +<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_not_equal_to</span><span class="special"><</span><span class="identifier">B</span><span class="special">>::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambiguous overload</span> +</pre> + </li> +<li class="listitem"> + There is an issue when applying this trait to template classes. If <code class="computeroutput"><span class="keyword">operator</span><span class="special">!=</span></code> + is defined but does not bind for a given template type, it is still detected + by the trait which returns <code class="computeroutput"><span class="keyword">true</span></code> + instead of <code class="computeroutput"><span class="keyword">false</span></code>. Example: + +<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_not_equal_to</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span> +<span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">iostream</span><span class="special">></span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">contains</span> <span class="special">{</span> <span class="identifier">T</span> <span class="identifier">data</span><span class="special">;</span> <span class="special">};</span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">!=(</span><span class="keyword">const</span> <span class="identifier">contains</span><span class="special"><</span><span class="identifier">T</span><span class="special">></span> <span class="special">&</span><span class="identifier">lhs</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">contains</span><span class="special"><</span><span class="identifier">T</span><span class="special">></span> <span class="special">&</span><span class="identifier">rhs</span><span class="special">)</span> <span class="special">{</span> + <span class="keyword">return</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">,</span> <span class="identifier">rhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">);</span> +<span class="special">}</span> + +<span class="keyword">class</span> <span class="identifier">bad</span> <span class="special">{</span> <span class="special">};</span> +<span class="keyword">class</span> <span class="identifier">good</span> <span class="special">{</span> <span class="special">};</span> +<span class="keyword">bool</span> <span class="identifier">f</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">good</span><span class="special">&,</span> <span class="keyword">const</span> <span class="identifier">good</span><span class="special">&)</span> <span class="special">{</span> <span class="special">}</span> + +<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span> <span class="special">{</span> + <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special"><<</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">boolalpha</span><span class="special">;</span> + <span class="comment">// works fine for contains<good></span> + <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special"><<</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_not_equal_to</span><span class="special"><</span> <span class="identifier">contains</span><span class="special"><</span> <span class="identifier">good</span> <span class="special">></span> <span class="special">>::</span><span class="identifier">value</span><span class="special"><<</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true</span> + <span class="identifier">contains</span><span class="special"><</span><span class="identifier">good</span><span class="special">></span> <span class="identifier">g</span><span class="special">;</span> + <span class="identifier">g</span><span class="special">!=</span><span class="identifier">g</span><span class="special">;</span> <span class="comment">// ok</span> + <span class="comment">// does not work for contains<bad></span> + <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special"><<</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_not_equal_to</span><span class="special"><</span> <span class="identifier">contains</span><span class="special"><</span> <span class="identifier">bad</span> <span class="special">></span> <span class="special">>::</span><span class="identifier">value</span><span class="special"><<</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true, should be false</span> + <span class="identifier">contains</span><span class="special"><</span><span class="identifier">bad</span><span class="special">></span> <span class="identifier">b</span><span class="special">;</span> + <span class="identifier">b</span><span class="special">!=</span><span class="identifier">b</span><span class="special">;</span> <span class="comment">// compile time error</span> + <span class="keyword">return</span> <span class="number">0</span><span class="special">;</span> +<span class="special">}</span> +</pre> + </li> +<li class="listitem"> + <code class="computeroutput"><span class="keyword">volatile</span></code> qualifier is not + properly handled and would lead to undefined behavior + </li> +</ul></div> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="has_new_operator.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="has_nothrow_assign.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/reference/has_nothrow_assign.html b/libs/type_traits/doc/html/boost_typetraits/reference/has_nothrow_assign.html new file mode 100644 index 0000000000..1d002064ca --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/reference/has_nothrow_assign.html @@ -0,0 +1,74 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>has_nothrow_assign</title> +<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../reference.html" title="Alphabetical Reference"> +<link rel="prev" href="has_not_equal_to.html" title="has_not_equal_to"> +<link rel="next" href="has_nothrow_constructor.html" title="has_nothrow_constructor"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td> +<td align="center"><a href="../../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="has_not_equal_to.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="has_nothrow_constructor.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h3 class="title"> +<a name="boost_typetraits.reference.has_nothrow_assign"></a><a class="link" href="has_nothrow_assign.html" title="has_nothrow_assign">has_nothrow_assign</a> +</h3></div></div></div> +<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">has_nothrow_assign</span> <span class="special">:</span> <span class="keyword">public</span> <em class="replaceable"><code><a class="link" href="integral_constant.html" title="integral_constant">true_type</a>-or-<a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code></em> <span class="special">{};</span> +</pre> +<p> + <span class="bold"><strong>Inherits:</strong></span> If T is a (possibly cv-qualified) + type with a non-throwing assignment-operator then inherits from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>, + otherwise inherits from <a class="link" href="integral_constant.html" title="integral_constant">false_type</a>. + Type <code class="computeroutput"><span class="identifier">T</span></code> must be a complete + type. + </p> +<p> + <span class="bold"><strong>Compiler Compatibility:</strong></span> If the compiler + does not support partial-specialization of class templates, then this template + can not be used with function types. + </p> +<p> + Without some (as yet unspecified) help from the compiler, <code class="computeroutput"><span class="identifier">has_nothrow_assign</span></code> + 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". + </p> +<p> + <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"> <span class="preprocessor">#include</span> + <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_nothrow_assign</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + </p> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="has_not_equal_to.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="has_nothrow_constructor.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/reference/has_nothrow_constructor.html b/libs/type_traits/doc/html/boost_typetraits/reference/has_nothrow_constructor.html new file mode 100644 index 0000000000..2dd674f4b7 --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/reference/has_nothrow_constructor.html @@ -0,0 +1,84 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>has_nothrow_constructor</title> +<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../reference.html" title="Alphabetical Reference"> +<link rel="prev" href="has_nothrow_assign.html" title="has_nothrow_assign"> +<link rel="next" href="has_nothrow_copy.html" title="has_nothrow_copy"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td> +<td align="center"><a href="../../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="has_nothrow_assign.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="has_nothrow_copy.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h3 class="title"> +<a name="boost_typetraits.reference.has_nothrow_constructor"></a><a class="link" href="has_nothrow_constructor.html" title="has_nothrow_constructor">has_nothrow_constructor</a> +</h3></div></div></div> +<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">has_nothrow_constructor</span> <span class="special">:</span> <span class="keyword">public</span> <em class="replaceable"><code><a class="link" href="integral_constant.html" title="integral_constant">true_type</a>-or-<a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code></em> <span class="special">{};</span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">has_nothrow_default_constructor</span> <span class="special">:</span> <span class="keyword">public</span> <em class="replaceable"><code><a class="link" href="integral_constant.html" title="integral_constant">true_type</a>-or-<a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code></em> <span class="special">{};</span> +</pre> +<p> + <span class="bold"><strong>Inherits:</strong></span> If T is a (possibly cv-qualified) + type with a non-throwing default-constructor then inherits from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>, + otherwise inherits from <a class="link" href="integral_constant.html" title="integral_constant">false_type</a>. + Type <code class="computeroutput"><span class="identifier">T</span></code> must be a complete + type. + </p> +<p> + These two traits are synonyms for each other. + </p> +<p> + <span class="bold"><strong>Compiler Compatibility:</strong></span> If the compiler + does not support partial-specialization of class templates, then this template + can not be used with function types. + </p> +<p> + Without some (unspecified) help from the compiler, <code class="computeroutput"><span class="identifier">has_nothrow_constructor</span></code> + will never report that a class or struct has a non-throwing default-constructor; + this is always safe, if possibly sub-optimal. Currently (May 2011) compilers + more recent than Visual C++ 8, GCC-4.3, Greenhills 6.0, Intel-11.0, and Codegear + have the necessary compiler <a class="link" href="../intrinsics.html" title="Support for Compiler Intrinsics">intrinsics</a> + to ensure that this trait "just works". You may also test to see + if the necessary <a class="link" href="../intrinsics.html" title="Support for Compiler Intrinsics">intrinsics</a> + are available by checking to see if the macro <code class="computeroutput"><span class="identifier">BOOST_HAS_NOTHROW_CONSTRUCTOR</span></code> + is defined. + </p> +<p> + <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"> <span class="preprocessor">#include</span> + <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_nothrow_constructor</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + </p> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="has_nothrow_assign.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="has_nothrow_copy.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/reference/has_nothrow_copy.html b/libs/type_traits/doc/html/boost_typetraits/reference/has_nothrow_copy.html new file mode 100644 index 0000000000..0e7064ab9b --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/reference/has_nothrow_copy.html @@ -0,0 +1,84 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>has_nothrow_copy</title> +<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../reference.html" title="Alphabetical Reference"> +<link rel="prev" href="has_nothrow_constructor.html" title="has_nothrow_constructor"> +<link rel="next" href="has_nothrow_cp_cons.html" title="has_nothrow_copy_constructor"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td> +<td align="center"><a href="../../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="has_nothrow_constructor.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="has_nothrow_cp_cons.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h3 class="title"> +<a name="boost_typetraits.reference.has_nothrow_copy"></a><a class="link" href="has_nothrow_copy.html" title="has_nothrow_copy">has_nothrow_copy</a> +</h3></div></div></div> +<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">has_nothrow_copy</span> <span class="special">:</span> <span class="keyword">public</span> <em class="replaceable"><code><a class="link" href="integral_constant.html" title="integral_constant">true_type</a>-or-<a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code></em> <span class="special">{};</span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">has_nothrow_copy_constructor</span> <span class="special">:</span> <span class="keyword">public</span> <em class="replaceable"><code><a class="link" href="integral_constant.html" title="integral_constant">true_type</a>-or-<a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code></em> <span class="special">{};</span> +</pre> +<p> + <span class="bold"><strong>Inherits:</strong></span> If T is a (possibly cv-qualified) + type with a non-throwing copy-constructor then inherits from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>, + otherwise inherits from <a class="link" href="integral_constant.html" title="integral_constant">false_type</a>. + Type <code class="computeroutput"><span class="identifier">T</span></code> must be a complete + type. + </p> +<p> + These two traits are synonyms for each other. + </p> +<p> + <span class="bold"><strong>Compiler Compatibility:</strong></span> If the compiler + does not support partial-specialization of class templates, then this template + can not be used with function types. + </p> +<p> + Without some (as yet unspecified) help from the compiler, <code class="computeroutput"><span class="identifier">has_nothrow_copy</span></code> + will never report that a class or struct has a non-throwing copy-constructor; + this is always safe, if possibly sub-optimal. Currently (May 2011) compilers + more recent than Visual C++ 8, GCC-4.3, Greenhills 6.0, Intel-11.0, and Codegear + have the necessary compiler <a class="link" href="../intrinsics.html" title="Support for Compiler Intrinsics">intrinsics</a> + to ensure that this trait "just works". You may also test to see + if the necessary <a class="link" href="../intrinsics.html" title="Support for Compiler Intrinsics">intrinsics</a> + are available by checking to see if the macro <code class="computeroutput"><span class="identifier">BOOST_HAS_NOTHROW_COPY</span></code> + is defined. + </p> +<p> + <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"> <span class="preprocessor">#include</span> + <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_nothrow_copy</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + </p> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="has_nothrow_constructor.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="has_nothrow_cp_cons.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/reference/has_nothrow_cp_cons.html b/libs/type_traits/doc/html/boost_typetraits/reference/has_nothrow_cp_cons.html new file mode 100644 index 0000000000..007d4ee04e --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/reference/has_nothrow_cp_cons.html @@ -0,0 +1,50 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>has_nothrow_copy_constructor</title> +<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../reference.html" title="Alphabetical Reference"> +<link rel="prev" href="has_nothrow_copy.html" title="has_nothrow_copy"> +<link rel="next" href="has_no_throw_def_cons.html" title="has_nothrow_default_constructor"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td> +<td align="center"><a href="../../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="has_nothrow_copy.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="has_no_throw_def_cons.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h3 class="title"> +<a name="boost_typetraits.reference.has_nothrow_cp_cons"></a><a class="link" href="has_nothrow_cp_cons.html" title="has_nothrow_copy_constructor">has_nothrow_copy_constructor</a> +</h3></div></div></div> +<p> + See <a class="link" href="has_nothrow_copy.html" title="has_nothrow_copy">has_nothrow_copy</a>. + </p> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="has_nothrow_copy.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="has_no_throw_def_cons.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/reference/has_plus.html b/libs/type_traits/doc/html/boost_typetraits/reference/has_plus.html new file mode 100644 index 0000000000..3a780c201b --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/reference/has_plus.html @@ -0,0 +1,196 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>has_plus</title> +<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../reference.html" title="Alphabetical Reference"> +<link rel="prev" href="has_no_throw_def_cons.html" title="has_nothrow_default_constructor"> +<link rel="next" href="has_plus_assign.html" title="has_plus_assign"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td> +<td align="center"><a href="../../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="has_no_throw_def_cons.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="has_plus_assign.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h3 class="title"> +<a name="boost_typetraits.reference.has_plus"></a><a class="link" href="has_plus.html" title="has_plus">has_plus</a> +</h3></div></div></div> +<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">Lhs</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Rhs</span><span class="special">=</span><span class="identifier">Lhs</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Ret</span><span class="special">=</span><span class="identifier">dont_care</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">has_plus</span> <span class="special">:</span> <span class="keyword">public</span> <em class="replaceable"><code><a class="link" href="integral_constant.html" title="integral_constant">true_type</a>-or-<a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code></em> <span class="special">{};</span> +</pre> +<p> + <span class="bold"><strong>Inherits:</strong></span> If (i) <code class="computeroutput"><span class="identifier">lhs</span></code> + of type <code class="computeroutput"><span class="identifier">Lhs</span></code> and <code class="computeroutput"><span class="identifier">rhs</span></code> of type <code class="computeroutput"><span class="identifier">Rhs</span></code> + can be used in expression <code class="computeroutput"><span class="identifier">lhs</span><span class="special">+</span><span class="identifier">rhs</span></code>, and + (ii) <code class="computeroutput"><span class="identifier">Ret</span><span class="special">=</span><span class="identifier">dont_care</span></code> or the result of expression + <code class="computeroutput"><span class="identifier">lhs</span><span class="special">+</span><span class="identifier">rhs</span></code> is convertible to <code class="computeroutput"><span class="identifier">Ret</span></code> + then inherits from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>, + otherwise inherits from <a class="link" href="integral_constant.html" title="integral_constant">false_type</a>. + </p> +<p> + The default behaviour (<code class="computeroutput"><span class="identifier">Ret</span><span class="special">=</span><span class="identifier">dont_care</span></code>) + is to not check for the return value of binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">+</span></code>. If <code class="computeroutput"><span class="identifier">Ret</span></code> + is different from the default <code class="computeroutput"><span class="identifier">dont_care</span></code> + type, the return value is checked to be convertible to <code class="computeroutput"><span class="identifier">Ret</span></code>. + Convertible to <code class="computeroutput"><span class="identifier">Ret</span></code> means + that the return value of the operator can be used as argument to a function + expecting <code class="computeroutput"><span class="identifier">Ret</span></code>: +</p> +<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">Ret</span><span class="special">);</span> +<span class="identifier">Lhs</span> <span class="identifier">lhs</span><span class="special">;</span> +<span class="identifier">Rhs</span> <span class="identifier">rhs</span><span class="special">;</span> +<span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">+</span><span class="identifier">rhs</span><span class="special">);</span> <span class="comment">// is valid if has_plus<Lhs, Rhs, Ret>::value==true</span> +</pre> +<p> + If <code class="computeroutput"><span class="identifier">Ret</span><span class="special">=</span><span class="keyword">void</span></code>, the return type is checked to be exactly + <code class="computeroutput"><span class="keyword">void</span></code>. + </p> +<p> + <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"><span class="preprocessor">#include</span> + <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_plus</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_operator</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + </p> +<p> + <span class="bold"><strong>Examples:</strong></span> + </p> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_plus</span><span class="special"><</span><span class="identifier">Lhs</span><span class="special">,</span> <span class="identifier">Rhs</span><span class="special">,</span> <span class="identifier">Ret</span><span class="special">>::</span><span class="identifier">value_type</span></code> is the type <code class="computeroutput"><span class="keyword">bool</span></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_plus</span><span class="special"><</span><span class="identifier">Lhs</span><span class="special">,</span> <span class="identifier">Rhs</span><span class="special">,</span> <span class="identifier">Ret</span><span class="special">>::</span><span class="identifier">value</span></code> is a <code class="computeroutput"><span class="keyword">bool</span></code> + integral constant expression. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_plus</span><span class="special"><</span><span class="keyword">int</span><span class="special">>::</span><span class="identifier">value</span></code> is a <code class="computeroutput"><span class="keyword">bool</span></code> + integral constant expression that evaluates to <code class="computeroutput"><span class="keyword">true</span></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_plus</span><span class="special"><</span><span class="keyword">long</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_plus</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_plus</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="keyword">long</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_plus</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">double</span><span class="special">></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_plus</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">int</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_plus</span><span class="special"><</span><span class="keyword">const</span> <span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">>::</span><span class="identifier">value</span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_plus</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>. + </p></blockquote></div> +<p> + <span class="bold"><strong>See also:</strong></span> <a class="link" href="../category/value_traits/operators.html" title="Operator Type Traits">Operator + Type Traits</a> + </p> +<p> + <span class="bold"><strong>Limitation:</strong></span> + </p> +<div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"> + Requires a compiler with working SFINAE. + </li></ul></div> +<p> + <span class="bold"><strong>Known issues:</strong></span> + </p> +<div class="itemizedlist"><ul class="itemizedlist" type="disc"> +<li class="listitem"> + This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">+</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">+</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">Lhs</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_plus</span><span class="special"><</span><span class="identifier">Lhs</span><span class="special">></span></code> + will produce a compiler error. For this reason <code class="computeroutput"><span class="identifier">has_plus</span></code> + cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">+</span></code> + or not. +<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">+(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&);</span> <span class="special">};</span> +<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_plus</span><span class="special"><</span><span class="identifier">A</span><span class="special">>::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator+(const A&) is private</span> +</pre> + </li> +<li class="listitem"> + There is an issue if the operator exists only for type <code class="computeroutput"><span class="identifier">A</span></code> and <code class="computeroutput"><span class="identifier">B</span></code> + is convertible to <code class="computeroutput"><span class="identifier">A</span></code>. + In this case, the compiler will report an ambiguous overload. +<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span> +<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">+(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&,</span> <span class="keyword">const</span> <span class="identifier">A</span><span class="special">&);</span> +<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span> +<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_plus</span><span class="special"><</span><span class="identifier">A</span><span class="special">>::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine</span> +<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_plus</span><span class="special"><</span><span class="identifier">B</span><span class="special">>::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambiguous overload</span> +</pre> + </li> +<li class="listitem"> + There is an issue when applying this trait to template classes. If <code class="computeroutput"><span class="keyword">operator</span><span class="special">+</span></code> + is defined but does not bind for a given template type, it is still detected + by the trait which returns <code class="computeroutput"><span class="keyword">true</span></code> + instead of <code class="computeroutput"><span class="keyword">false</span></code>. Example: + +<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_plus</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span> +<span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">iostream</span><span class="special">></span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">contains</span> <span class="special">{</span> <span class="identifier">T</span> <span class="identifier">data</span><span class="special">;</span> <span class="special">};</span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">+(</span><span class="keyword">const</span> <span class="identifier">contains</span><span class="special"><</span><span class="identifier">T</span><span class="special">></span> <span class="special">&</span><span class="identifier">lhs</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">contains</span><span class="special"><</span><span class="identifier">T</span><span class="special">></span> <span class="special">&</span><span class="identifier">rhs</span><span class="special">)</span> <span class="special">{</span> + <span class="keyword">return</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">,</span> <span class="identifier">rhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">);</span> +<span class="special">}</span> + +<span class="keyword">class</span> <span class="identifier">bad</span> <span class="special">{</span> <span class="special">};</span> +<span class="keyword">class</span> <span class="identifier">good</span> <span class="special">{</span> <span class="special">};</span> +<span class="keyword">bool</span> <span class="identifier">f</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">good</span><span class="special">&,</span> <span class="keyword">const</span> <span class="identifier">good</span><span class="special">&)</span> <span class="special">{</span> <span class="special">}</span> + +<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span> <span class="special">{</span> + <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special"><<</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">boolalpha</span><span class="special">;</span> + <span class="comment">// works fine for contains<good></span> + <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special"><<</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_plus</span><span class="special"><</span> <span class="identifier">contains</span><span class="special"><</span> <span class="identifier">good</span> <span class="special">></span> <span class="special">>::</span><span class="identifier">value</span><span class="special"><<</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true</span> + <span class="identifier">contains</span><span class="special"><</span><span class="identifier">good</span><span class="special">></span> <span class="identifier">g</span><span class="special">;</span> + <span class="identifier">g</span><span class="special">+</span><span class="identifier">g</span><span class="special">;</span> <span class="comment">// ok</span> + <span class="comment">// does not work for contains<bad></span> + <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special"><<</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_plus</span><span class="special"><</span> <span class="identifier">contains</span><span class="special"><</span> <span class="identifier">bad</span> <span class="special">></span> <span class="special">>::</span><span class="identifier">value</span><span class="special"><<</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true, should be false</span> + <span class="identifier">contains</span><span class="special"><</span><span class="identifier">bad</span><span class="special">></span> <span class="identifier">b</span><span class="special">;</span> + <span class="identifier">b</span><span class="special">+</span><span class="identifier">b</span><span class="special">;</span> <span class="comment">// compile time error</span> + <span class="keyword">return</span> <span class="number">0</span><span class="special">;</span> +<span class="special">}</span> +</pre> + </li> +<li class="listitem"> + <code class="computeroutput"><span class="keyword">volatile</span></code> qualifier is not + properly handled and would lead to undefined behavior + </li> +</ul></div> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="has_no_throw_def_cons.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="has_plus_assign.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/reference/has_plus_assign.html b/libs/type_traits/doc/html/boost_typetraits/reference/has_plus_assign.html new file mode 100644 index 0000000000..552ba55223 --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/reference/has_plus_assign.html @@ -0,0 +1,198 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>has_plus_assign</title> +<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../reference.html" title="Alphabetical Reference"> +<link rel="prev" href="has_plus.html" title="has_plus"> +<link rel="next" href="has_post_decrement.html" title="has_post_decrement"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td> +<td align="center"><a href="../../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="has_plus.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="has_post_decrement.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h3 class="title"> +<a name="boost_typetraits.reference.has_plus_assign"></a><a class="link" href="has_plus_assign.html" title="has_plus_assign">has_plus_assign</a> +</h3></div></div></div> +<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">Lhs</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Rhs</span><span class="special">=</span><span class="identifier">Lhs</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Ret</span><span class="special">=</span><span class="identifier">dont_care</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">has_plus_assign</span> <span class="special">:</span> <span class="keyword">public</span> <em class="replaceable"><code><a class="link" href="integral_constant.html" title="integral_constant">true_type</a>-or-<a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code></em> <span class="special">{};</span> +</pre> +<p> + <span class="bold"><strong>Inherits:</strong></span> If (i) <code class="computeroutput"><span class="identifier">lhs</span></code> + of type <code class="computeroutput"><span class="identifier">Lhs</span></code> and <code class="computeroutput"><span class="identifier">rhs</span></code> of type <code class="computeroutput"><span class="identifier">Rhs</span></code> + can be used in expression <code class="computeroutput"><span class="identifier">lhs</span><span class="special">+=</span><span class="identifier">rhs</span></code>, + and (ii) <code class="computeroutput"><span class="identifier">Ret</span><span class="special">=</span><span class="identifier">dont_care</span></code> or the result of expression + <code class="computeroutput"><span class="identifier">lhs</span><span class="special">+=</span><span class="identifier">rhs</span></code> is convertible to <code class="computeroutput"><span class="identifier">Ret</span></code> + then inherits from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>, + otherwise inherits from <a class="link" href="integral_constant.html" title="integral_constant">false_type</a>. + </p> +<p> + The default behaviour (<code class="computeroutput"><span class="identifier">Ret</span><span class="special">=</span><span class="identifier">dont_care</span></code>) + is to not check for the return value of binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">+=</span></code>. If <code class="computeroutput"><span class="identifier">Ret</span></code> + is different from the default <code class="computeroutput"><span class="identifier">dont_care</span></code> + type, the return value is checked to be convertible to <code class="computeroutput"><span class="identifier">Ret</span></code>. + Convertible to <code class="computeroutput"><span class="identifier">Ret</span></code> means + that the return value of the operator can be used as argument to a function + expecting <code class="computeroutput"><span class="identifier">Ret</span></code>: +</p> +<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">Ret</span><span class="special">);</span> +<span class="identifier">Lhs</span> <span class="identifier">lhs</span><span class="special">;</span> +<span class="identifier">Rhs</span> <span class="identifier">rhs</span><span class="special">;</span> +<span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">+=</span><span class="identifier">rhs</span><span class="special">);</span> <span class="comment">// is valid if has_plus_assign<Lhs, Rhs, Ret>::value==true</span> +</pre> +<p> + If <code class="computeroutput"><span class="identifier">Ret</span><span class="special">=</span><span class="keyword">void</span></code>, the return type is checked to be exactly + <code class="computeroutput"><span class="keyword">void</span></code>. + </p> +<p> + <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"><span class="preprocessor">#include</span> + <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_plus_assign</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_operator</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + </p> +<p> + <span class="bold"><strong>Examples:</strong></span> + </p> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_plus_assign</span><span class="special"><</span><span class="identifier">Lhs</span><span class="special">,</span> <span class="identifier">Rhs</span><span class="special">,</span> <span class="identifier">Ret</span><span class="special">>::</span><span class="identifier">value_type</span></code> is the type <code class="computeroutput"><span class="keyword">bool</span></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_plus_assign</span><span class="special"><</span><span class="identifier">Lhs</span><span class="special">,</span> <span class="identifier">Rhs</span><span class="special">,</span> <span class="identifier">Ret</span><span class="special">>::</span><span class="identifier">value</span></code> is a <code class="computeroutput"><span class="keyword">bool</span></code> + integral constant expression. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_plus_assign</span><span class="special"><</span><span class="keyword">int</span><span class="special">>::</span><span class="identifier">value</span></code> is a <code class="computeroutput"><span class="keyword">bool</span></code> + integral constant expression that evaluates to <code class="computeroutput"><span class="keyword">true</span></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_plus_assign</span><span class="special"><</span><span class="keyword">long</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_plus_assign</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_plus_assign</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="keyword">long</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_plus_assign</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">double</span><span class="special">></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_plus_assign</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">int</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_plus_assign</span><span class="special"><</span><span class="keyword">const</span> <span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">>::</span><span class="identifier">value</span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_plus_assign</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>. + </p></blockquote></div> +<p> + <span class="bold"><strong>See also:</strong></span> <a class="link" href="../category/value_traits/operators.html" title="Operator Type Traits">Operator + Type Traits</a> + </p> +<p> + <span class="bold"><strong>Limitation:</strong></span> + </p> +<div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"> + Requires a compiler with working SFINAE. + </li></ul></div> +<p> + <span class="bold"><strong>Known issues:</strong></span> + </p> +<div class="itemizedlist"><ul class="itemizedlist" type="disc"> +<li class="listitem"> + This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">+=</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">+=</span></code> + is defined as a private member of <code class="computeroutput"><span class="identifier">Lhs</span></code> + then instantiating <code class="computeroutput"><span class="identifier">has_plus_assign</span><span class="special"><</span><span class="identifier">Lhs</span><span class="special">></span></code> will produce a compiler error. For + this reason <code class="computeroutput"><span class="identifier">has_plus_assign</span></code> + cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">+=</span></code> + or not. +<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">+=(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&);</span> <span class="special">};</span> +<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_plus_assign</span><span class="special"><</span><span class="identifier">A</span><span class="special">>::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator+=(const A&) is private</span> +</pre> + </li> +<li class="listitem"> + There is an issue if the operator exists only for type <code class="computeroutput"><span class="identifier">A</span></code> and <code class="computeroutput"><span class="identifier">B</span></code> + is convertible to <code class="computeroutput"><span class="identifier">A</span></code>. + In this case, the compiler will report an ambiguous overload. +<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span> +<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">+=(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&,</span> <span class="keyword">const</span> <span class="identifier">A</span><span class="special">&);</span> +<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span> +<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_plus_assign</span><span class="special"><</span><span class="identifier">A</span><span class="special">>::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine</span> +<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_plus_assign</span><span class="special"><</span><span class="identifier">B</span><span class="special">>::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambiguous overload</span> +</pre> + </li> +<li class="listitem"> + There is an issue when applying this trait to template classes. If <code class="computeroutput"><span class="keyword">operator</span><span class="special">+=</span></code> + is defined but does not bind for a given template type, it is still detected + by the trait which returns <code class="computeroutput"><span class="keyword">true</span></code> + instead of <code class="computeroutput"><span class="keyword">false</span></code>. Example: + +<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_plus_assign</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span> +<span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">iostream</span><span class="special">></span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">contains</span> <span class="special">{</span> <span class="identifier">T</span> <span class="identifier">data</span><span class="special">;</span> <span class="special">};</span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">+=(</span><span class="keyword">const</span> <span class="identifier">contains</span><span class="special"><</span><span class="identifier">T</span><span class="special">></span> <span class="special">&</span><span class="identifier">lhs</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">contains</span><span class="special"><</span><span class="identifier">T</span><span class="special">></span> <span class="special">&</span><span class="identifier">rhs</span><span class="special">)</span> <span class="special">{</span> + <span class="keyword">return</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">,</span> <span class="identifier">rhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">);</span> +<span class="special">}</span> + +<span class="keyword">class</span> <span class="identifier">bad</span> <span class="special">{</span> <span class="special">};</span> +<span class="keyword">class</span> <span class="identifier">good</span> <span class="special">{</span> <span class="special">};</span> +<span class="keyword">bool</span> <span class="identifier">f</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">good</span><span class="special">&,</span> <span class="keyword">const</span> <span class="identifier">good</span><span class="special">&)</span> <span class="special">{</span> <span class="special">}</span> + +<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span> <span class="special">{</span> + <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special"><<</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">boolalpha</span><span class="special">;</span> + <span class="comment">// works fine for contains<good></span> + <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special"><<</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_plus_assign</span><span class="special"><</span> <span class="identifier">contains</span><span class="special"><</span> <span class="identifier">good</span> <span class="special">></span> <span class="special">>::</span><span class="identifier">value</span><span class="special"><<</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true</span> + <span class="identifier">contains</span><span class="special"><</span><span class="identifier">good</span><span class="special">></span> <span class="identifier">g</span><span class="special">;</span> + <span class="identifier">g</span><span class="special">+=</span><span class="identifier">g</span><span class="special">;</span> <span class="comment">// ok</span> + <span class="comment">// does not work for contains<bad></span> + <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special"><<</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_plus_assign</span><span class="special"><</span> <span class="identifier">contains</span><span class="special"><</span> <span class="identifier">bad</span> <span class="special">></span> <span class="special">>::</span><span class="identifier">value</span><span class="special"><<</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true, should be false</span> + <span class="identifier">contains</span><span class="special"><</span><span class="identifier">bad</span><span class="special">></span> <span class="identifier">b</span><span class="special">;</span> + <span class="identifier">b</span><span class="special">+=</span><span class="identifier">b</span><span class="special">;</span> <span class="comment">// compile time error</span> + <span class="keyword">return</span> <span class="number">0</span><span class="special">;</span> +<span class="special">}</span> +</pre> + </li> +<li class="listitem"> + <code class="computeroutput"><span class="keyword">volatile</span></code> qualifier is not + properly handled and would lead to undefined behavior + </li> +</ul></div> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="has_plus.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="has_post_decrement.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/reference/has_post_decrement.html b/libs/type_traits/doc/html/boost_typetraits/reference/has_post_decrement.html new file mode 100644 index 0000000000..175023f2e1 --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/reference/has_post_decrement.html @@ -0,0 +1,205 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>has_post_decrement</title> +<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../reference.html" title="Alphabetical Reference"> +<link rel="prev" href="has_plus_assign.html" title="has_plus_assign"> +<link rel="next" href="has_post_increment.html" title="has_post_increment"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td> +<td align="center"><a href="../../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="has_plus_assign.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="has_post_increment.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h3 class="title"> +<a name="boost_typetraits.reference.has_post_decrement"></a><a class="link" href="has_post_decrement.html" title="has_post_decrement">has_post_decrement</a> +</h3></div></div></div> +<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">Lhs</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Ret</span><span class="special">=</span><span class="identifier">dont_care</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">has_post_decrement</span> <span class="special">:</span> <span class="keyword">public</span> <em class="replaceable"><code><a class="link" href="integral_constant.html" title="integral_constant">true_type</a>-or-<a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code></em> <span class="special">{};</span> +</pre> +<p> + <span class="bold"><strong>Inherits:</strong></span> If (i) <code class="computeroutput"><span class="identifier">lhs</span></code> + of type <code class="computeroutput"><span class="identifier">Lhs</span></code> can be used in + expression <code class="computeroutput"><span class="identifier">lhs</span><span class="special">--</span></code>, + and (ii) <code class="computeroutput"><span class="identifier">Ret</span><span class="special">=</span><span class="identifier">dont_care</span></code> or the result of expression + <code class="computeroutput"><span class="identifier">lhs</span><span class="special">--</span></code> + is convertible to <code class="computeroutput"><span class="identifier">Ret</span></code> then + inherits from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>, + otherwise inherits from <a class="link" href="integral_constant.html" title="integral_constant">false_type</a>. + </p> +<p> + The default behaviour (<code class="computeroutput"><span class="identifier">Ret</span><span class="special">=</span><span class="identifier">dont_care</span></code>) + is to not check for the return value of postfix <code class="computeroutput"><span class="keyword">operator</span><span class="special">--</span></code>. If <code class="computeroutput"><span class="identifier">Ret</span></code> + is different from the default <code class="computeroutput"><span class="identifier">dont_care</span></code> + type, the return value is checked to be convertible to <code class="computeroutput"><span class="identifier">Ret</span></code>. + Convertible to <code class="computeroutput"><span class="identifier">Ret</span></code> means + that the return value of the operator can be used as argument to a function + expecting <code class="computeroutput"><span class="identifier">Ret</span></code>: +</p> +<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">Ret</span><span class="special">);</span> +<span class="identifier">Lhs</span> <span class="identifier">lhs</span><span class="special">;</span> +<span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">--);</span> <span class="comment">// is valid if has_post_decrement<Lhs, Ret>::value==true</span> +</pre> +<p> + If <code class="computeroutput"><span class="identifier">Ret</span><span class="special">=</span><span class="keyword">void</span></code>, the return type is checked to be exactly + <code class="computeroutput"><span class="keyword">void</span></code>. + </p> +<p> + <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"><span class="preprocessor">#include</span> + <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_post_decrement</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_operator</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + </p> +<p> + <span class="bold"><strong>Examples:</strong></span> + </p> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_post_decrement</span><span class="special"><</span><span class="identifier">Lhs</span><span class="special">,</span> <span class="identifier">Ret</span><span class="special">>::</span><span class="identifier">value_type</span></code> is the type <code class="computeroutput"><span class="keyword">bool</span></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_post_decrement</span><span class="special"><</span><span class="identifier">Lhs</span><span class="special">,</span> <span class="identifier">Ret</span><span class="special">>::</span><span class="identifier">value</span></code> is a <code class="computeroutput"><span class="keyword">bool</span></code> + integral constant expression. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_post_decrement</span><span class="special"><</span><span class="keyword">int</span><span class="special">>::</span><span class="identifier">value</span></code> is a <code class="computeroutput"><span class="keyword">bool</span></code> + integral constant expression that evaluates to <code class="computeroutput"><span class="keyword">true</span></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_post_decrement</span><span class="special"><</span><span class="keyword">long</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_post_decrement</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_post_decrement</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">long</span><span class="special">></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_post_decrement</span><span class="special"><</span><span class="keyword">double</span><span class="special">,</span> <span class="keyword">double</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_post_decrement</span><span class="special"><</span><span class="keyword">double</span><span class="special">,</span> <span class="keyword">int</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_post_decrement</span><span class="special"><</span><span class="keyword">bool</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_post_decrement</span><span class="special"><</span><span class="keyword">const</span> <span class="keyword">int</span><span class="special">></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_post_decrement</span><span class="special"><</span><span class="keyword">void</span><span class="special">*></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_post_decrement</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>. + </p></blockquote></div> +<p> + <span class="bold"><strong>See also:</strong></span> <a class="link" href="../category/value_traits/operators.html" title="Operator Type Traits">Operator + Type Traits</a> + </p> +<p> + <span class="bold"><strong>Limitation:</strong></span> + </p> +<div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"> + Requires a compiler with working SFINAE. + </li></ul></div> +<p> + <span class="bold"><strong>Known issues:</strong></span> + </p> +<div class="itemizedlist"><ul class="itemizedlist" type="disc"> +<li class="listitem"> + This trait cannot detect whether postfix <code class="computeroutput"><span class="keyword">operator</span><span class="special">--</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">--</span></code> + is defined as a private member of <code class="computeroutput"><span class="identifier">Lhs</span></code> + then instantiating <code class="computeroutput"><span class="identifier">has_post_decrement</span><span class="special"><</span><span class="identifier">Lhs</span><span class="special">></span></code> will produce a compiler error. For + this reason <code class="computeroutput"><span class="identifier">has_post_decrement</span></code> + cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">--</span></code> + or not. +<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">--(</span><span class="keyword">int</span><span class="special">);</span> <span class="special">};</span> +<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_post_decrement</span><span class="special"><</span><span class="identifier">A</span><span class="special">>::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator--(int) is private</span> +</pre> + </li> +<li class="listitem"> + There is an issue if the operator exists only for type <code class="computeroutput"><span class="identifier">A</span></code> and <code class="computeroutput"><span class="identifier">B</span></code> + is convertible to <code class="computeroutput"><span class="identifier">A</span></code>. + In this case, the compiler will report an ambiguous overload. +<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span> +<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">--(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&,</span> <span class="keyword">int</span><span class="special">);</span> +<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span> +<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_post_decrement</span><span class="special"><</span><span class="identifier">A</span><span class="special">>::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine</span> +<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_post_decrement</span><span class="special"><</span><span class="identifier">B</span><span class="special">>::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambiguous overload</span> +</pre> + </li> +<li class="listitem"> + There is an issue when applying this trait to template classes. If <code class="computeroutput"><span class="keyword">operator</span><span class="special">--</span></code> + is defined but does not bind for a given template type, it is still detected + by the trait which returns <code class="computeroutput"><span class="keyword">true</span></code> + instead of <code class="computeroutput"><span class="keyword">false</span></code>. Example: + +<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_post_decrement</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span> +<span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">iostream</span><span class="special">></span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">contains</span> <span class="special">{</span> <span class="identifier">T</span> <span class="identifier">data</span><span class="special">;</span> <span class="special">};</span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">--(</span><span class="keyword">const</span> <span class="identifier">contains</span><span class="special"><</span><span class="identifier">T</span><span class="special">></span> <span class="special">&</span><span class="identifier">lhs</span><span class="special">,</span> <span class="keyword">int</span><span class="special">)</span> <span class="special">{</span> + <span class="keyword">return</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">);</span> +<span class="special">}</span> + +<span class="keyword">class</span> <span class="identifier">bad</span> <span class="special">{</span> <span class="special">};</span> +<span class="keyword">class</span> <span class="identifier">good</span> <span class="special">{</span> <span class="special">};</span> +<span class="keyword">bool</span> <span class="identifier">f</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">good</span><span class="special">&,</span> <span class="keyword">const</span> <span class="identifier">good</span><span class="special">&)</span> <span class="special">{</span> <span class="special">}</span> + +<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span> <span class="special">{</span> + <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special"><<</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">boolalpha</span><span class="special">;</span> + <span class="comment">// works fine for contains<good></span> + <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special"><<</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_post_decrement</span><span class="special"><</span> <span class="identifier">contains</span><span class="special"><</span> <span class="identifier">good</span> <span class="special">></span> <span class="special">>::</span><span class="identifier">value</span><span class="special"><<</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true</span> + <span class="identifier">contains</span><span class="special"><</span><span class="identifier">good</span><span class="special">></span> <span class="identifier">g</span><span class="special">;</span> + <span class="identifier">g</span><span class="special">--;</span> <span class="comment">// ok</span> + <span class="comment">// does not work for contains<bad></span> + <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special"><<</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_post_decrement</span><span class="special"><</span> <span class="identifier">contains</span><span class="special"><</span> <span class="identifier">bad</span> <span class="special">></span> <span class="special">>::</span><span class="identifier">value</span><span class="special"><<</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true, should be false</span> + <span class="identifier">contains</span><span class="special"><</span><span class="identifier">bad</span><span class="special">></span> <span class="identifier">b</span><span class="special">;</span> + <span class="identifier">b</span><span class="special">--;</span> <span class="comment">// compile time error</span> + <span class="keyword">return</span> <span class="number">0</span><span class="special">;</span> +<span class="special">}</span> +</pre> + </li> +<li class="listitem"> + <code class="computeroutput"><span class="keyword">volatile</span></code> qualifier is not + properly handled and would lead to undefined behavior + </li> +</ul></div> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="has_plus_assign.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="has_post_increment.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/reference/has_post_increment.html b/libs/type_traits/doc/html/boost_typetraits/reference/has_post_increment.html new file mode 100644 index 0000000000..0830cb7c2b --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/reference/has_post_increment.html @@ -0,0 +1,205 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>has_post_increment</title> +<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../reference.html" title="Alphabetical Reference"> +<link rel="prev" href="has_post_decrement.html" title="has_post_decrement"> +<link rel="next" href="has_pre_decrement.html" title="has_pre_decrement"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td> +<td align="center"><a href="../../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="has_post_decrement.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="has_pre_decrement.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h3 class="title"> +<a name="boost_typetraits.reference.has_post_increment"></a><a class="link" href="has_post_increment.html" title="has_post_increment">has_post_increment</a> +</h3></div></div></div> +<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">Lhs</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Ret</span><span class="special">=</span><span class="identifier">dont_care</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">has_post_increment</span> <span class="special">:</span> <span class="keyword">public</span> <em class="replaceable"><code><a class="link" href="integral_constant.html" title="integral_constant">true_type</a>-or-<a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code></em> <span class="special">{};</span> +</pre> +<p> + <span class="bold"><strong>Inherits:</strong></span> If (i) <code class="computeroutput"><span class="identifier">lhs</span></code> + of type <code class="computeroutput"><span class="identifier">Lhs</span></code> can be used in + expression <code class="computeroutput"><span class="identifier">lhs</span><span class="special">++</span></code>, + and (ii) <code class="computeroutput"><span class="identifier">Ret</span><span class="special">=</span><span class="identifier">dont_care</span></code> or the result of expression + <code class="computeroutput"><span class="identifier">lhs</span><span class="special">++</span></code> + is convertible to <code class="computeroutput"><span class="identifier">Ret</span></code> then + inherits from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>, + otherwise inherits from <a class="link" href="integral_constant.html" title="integral_constant">false_type</a>. + </p> +<p> + The default behaviour (<code class="computeroutput"><span class="identifier">Ret</span><span class="special">=</span><span class="identifier">dont_care</span></code>) + is to not check for the return value of postfix <code class="computeroutput"><span class="keyword">operator</span><span class="special">++</span></code>. If <code class="computeroutput"><span class="identifier">Ret</span></code> + is different from the default <code class="computeroutput"><span class="identifier">dont_care</span></code> + type, the return value is checked to be convertible to <code class="computeroutput"><span class="identifier">Ret</span></code>. + Convertible to <code class="computeroutput"><span class="identifier">Ret</span></code> means + that the return value of the operator can be used as argument to a function + expecting <code class="computeroutput"><span class="identifier">Ret</span></code>: +</p> +<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">Ret</span><span class="special">);</span> +<span class="identifier">Lhs</span> <span class="identifier">lhs</span><span class="special">;</span> +<span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">++);</span> <span class="comment">// is valid if has_post_increment<Lhs, Ret>::value==true</span> +</pre> +<p> + If <code class="computeroutput"><span class="identifier">Ret</span><span class="special">=</span><span class="keyword">void</span></code>, the return type is checked to be exactly + <code class="computeroutput"><span class="keyword">void</span></code>. + </p> +<p> + <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"><span class="preprocessor">#include</span> + <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_post_increment</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_operator</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + </p> +<p> + <span class="bold"><strong>Examples:</strong></span> + </p> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_post_increment</span><span class="special"><</span><span class="identifier">Lhs</span><span class="special">,</span> <span class="identifier">Ret</span><span class="special">>::</span><span class="identifier">value_type</span></code> is the type <code class="computeroutput"><span class="keyword">bool</span></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_post_increment</span><span class="special"><</span><span class="identifier">Lhs</span><span class="special">,</span> <span class="identifier">Ret</span><span class="special">>::</span><span class="identifier">value</span></code> is a <code class="computeroutput"><span class="keyword">bool</span></code> + integral constant expression. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_post_increment</span><span class="special"><</span><span class="keyword">int</span><span class="special">>::</span><span class="identifier">value</span></code> is a <code class="computeroutput"><span class="keyword">bool</span></code> + integral constant expression that evaluates to <code class="computeroutput"><span class="keyword">true</span></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_post_increment</span><span class="special"><</span><span class="keyword">long</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_post_increment</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_post_increment</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">long</span><span class="special">></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_post_increment</span><span class="special"><</span><span class="keyword">double</span><span class="special">,</span> <span class="keyword">double</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_post_increment</span><span class="special"><</span><span class="keyword">double</span><span class="special">,</span> <span class="keyword">int</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_post_increment</span><span class="special"><</span><span class="keyword">bool</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_post_increment</span><span class="special"><</span><span class="keyword">const</span> <span class="keyword">int</span><span class="special">></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_post_increment</span><span class="special"><</span><span class="keyword">void</span><span class="special">*></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_post_increment</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>. + </p></blockquote></div> +<p> + <span class="bold"><strong>See also:</strong></span> <a class="link" href="../category/value_traits/operators.html" title="Operator Type Traits">Operator + Type Traits</a> + </p> +<p> + <span class="bold"><strong>Limitation:</strong></span> + </p> +<div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"> + Requires a compiler with working SFINAE. + </li></ul></div> +<p> + <span class="bold"><strong>Known issues:</strong></span> + </p> +<div class="itemizedlist"><ul class="itemizedlist" type="disc"> +<li class="listitem"> + This trait cannot detect whether postfix <code class="computeroutput"><span class="keyword">operator</span><span class="special">++</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">++</span></code> + is defined as a private member of <code class="computeroutput"><span class="identifier">Lhs</span></code> + then instantiating <code class="computeroutput"><span class="identifier">has_post_increment</span><span class="special"><</span><span class="identifier">Lhs</span><span class="special">></span></code> will produce a compiler error. For + this reason <code class="computeroutput"><span class="identifier">has_post_increment</span></code> + cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">++</span></code> + or not. +<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">++(</span><span class="keyword">int</span><span class="special">);</span> <span class="special">};</span> +<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_post_increment</span><span class="special"><</span><span class="identifier">A</span><span class="special">>::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator++(int) is private</span> +</pre> + </li> +<li class="listitem"> + There is an issue if the operator exists only for type <code class="computeroutput"><span class="identifier">A</span></code> and <code class="computeroutput"><span class="identifier">B</span></code> + is convertible to <code class="computeroutput"><span class="identifier">A</span></code>. + In this case, the compiler will report an ambiguous overload. +<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span> +<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">++(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&,</span> <span class="keyword">int</span><span class="special">);</span> +<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span> +<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_post_increment</span><span class="special"><</span><span class="identifier">A</span><span class="special">>::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine</span> +<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_post_increment</span><span class="special"><</span><span class="identifier">B</span><span class="special">>::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambiguous overload</span> +</pre> + </li> +<li class="listitem"> + There is an issue when applying this trait to template classes. If <code class="computeroutput"><span class="keyword">operator</span><span class="special">++</span></code> + is defined but does not bind for a given template type, it is still detected + by the trait which returns <code class="computeroutput"><span class="keyword">true</span></code> + instead of <code class="computeroutput"><span class="keyword">false</span></code>. Example: + +<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_post_increment</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span> +<span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">iostream</span><span class="special">></span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">contains</span> <span class="special">{</span> <span class="identifier">T</span> <span class="identifier">data</span><span class="special">;</span> <span class="special">};</span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">++(</span><span class="keyword">const</span> <span class="identifier">contains</span><span class="special"><</span><span class="identifier">T</span><span class="special">></span> <span class="special">&</span><span class="identifier">lhs</span><span class="special">,</span> <span class="keyword">int</span><span class="special">)</span> <span class="special">{</span> + <span class="keyword">return</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">);</span> +<span class="special">}</span> + +<span class="keyword">class</span> <span class="identifier">bad</span> <span class="special">{</span> <span class="special">};</span> +<span class="keyword">class</span> <span class="identifier">good</span> <span class="special">{</span> <span class="special">};</span> +<span class="keyword">bool</span> <span class="identifier">f</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">good</span><span class="special">&,</span> <span class="keyword">const</span> <span class="identifier">good</span><span class="special">&)</span> <span class="special">{</span> <span class="special">}</span> + +<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span> <span class="special">{</span> + <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special"><<</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">boolalpha</span><span class="special">;</span> + <span class="comment">// works fine for contains<good></span> + <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special"><<</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_post_increment</span><span class="special"><</span> <span class="identifier">contains</span><span class="special"><</span> <span class="identifier">good</span> <span class="special">></span> <span class="special">>::</span><span class="identifier">value</span><span class="special"><<</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true</span> + <span class="identifier">contains</span><span class="special"><</span><span class="identifier">good</span><span class="special">></span> <span class="identifier">g</span><span class="special">;</span> + <span class="identifier">g</span><span class="special">++;</span> <span class="comment">// ok</span> + <span class="comment">// does not work for contains<bad></span> + <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special"><<</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_post_increment</span><span class="special"><</span> <span class="identifier">contains</span><span class="special"><</span> <span class="identifier">bad</span> <span class="special">></span> <span class="special">>::</span><span class="identifier">value</span><span class="special"><<</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true, should be false</span> + <span class="identifier">contains</span><span class="special"><</span><span class="identifier">bad</span><span class="special">></span> <span class="identifier">b</span><span class="special">;</span> + <span class="identifier">b</span><span class="special">++;</span> <span class="comment">// compile time error</span> + <span class="keyword">return</span> <span class="number">0</span><span class="special">;</span> +<span class="special">}</span> +</pre> + </li> +<li class="listitem"> + <code class="computeroutput"><span class="keyword">volatile</span></code> qualifier is not + properly handled and would lead to undefined behavior + </li> +</ul></div> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="has_post_decrement.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="has_pre_decrement.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/reference/has_pre_decrement.html b/libs/type_traits/doc/html/boost_typetraits/reference/has_pre_decrement.html new file mode 100644 index 0000000000..b141de4caa --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/reference/has_pre_decrement.html @@ -0,0 +1,205 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>has_pre_decrement</title> +<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../reference.html" title="Alphabetical Reference"> +<link rel="prev" href="has_post_increment.html" title="has_post_increment"> +<link rel="next" href="has_pre_increment.html" title="has_pre_increment"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td> +<td align="center"><a href="../../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="has_post_increment.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="has_pre_increment.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h3 class="title"> +<a name="boost_typetraits.reference.has_pre_decrement"></a><a class="link" href="has_pre_decrement.html" title="has_pre_decrement">has_pre_decrement</a> +</h3></div></div></div> +<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">Rhs</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Ret</span><span class="special">=</span><span class="identifier">dont_care</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">has_pre_decrement</span> <span class="special">:</span> <span class="keyword">public</span> <em class="replaceable"><code><a class="link" href="integral_constant.html" title="integral_constant">true_type</a>-or-<a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code></em> <span class="special">{};</span> +</pre> +<p> + <span class="bold"><strong>Inherits:</strong></span> If (i) <code class="computeroutput"><span class="identifier">rhs</span></code> + of type <code class="computeroutput"><span class="identifier">Rhs</span></code> can be used in + expression <code class="computeroutput"><span class="special">--</span><span class="identifier">rhs</span></code>, + and (ii) <code class="computeroutput"><span class="identifier">Ret</span><span class="special">=</span><span class="identifier">dont_care</span></code> or the result of expression + <code class="computeroutput"><span class="special">--</span><span class="identifier">rhs</span></code> + is convertible to <code class="computeroutput"><span class="identifier">Ret</span></code> then + inherits from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>, + otherwise inherits from <a class="link" href="integral_constant.html" title="integral_constant">false_type</a>. + </p> +<p> + The default behaviour (<code class="computeroutput"><span class="identifier">Ret</span><span class="special">=</span><span class="identifier">dont_care</span></code>) + is to not check for the return value of prefix <code class="computeroutput"><span class="keyword">operator</span><span class="special">--</span></code>. If <code class="computeroutput"><span class="identifier">Ret</span></code> + is different from the default <code class="computeroutput"><span class="identifier">dont_care</span></code> + type, the return value is checked to be convertible to <code class="computeroutput"><span class="identifier">Ret</span></code>. + Convertible to <code class="computeroutput"><span class="identifier">Ret</span></code> means + that the return value of the operator can be used as argument to a function + expecting <code class="computeroutput"><span class="identifier">Ret</span></code>: +</p> +<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">Ret</span><span class="special">);</span> +<span class="identifier">Rhs</span> <span class="identifier">rhs</span><span class="special">;</span> +<span class="identifier">f</span><span class="special">(--</span><span class="identifier">rhs</span><span class="special">);</span> <span class="comment">// is valid if has_pre_decrement<Rhs, Ret>::value==true</span> +</pre> +<p> + If <code class="computeroutput"><span class="identifier">Ret</span><span class="special">=</span><span class="keyword">void</span></code>, the return type is checked to be exactly + <code class="computeroutput"><span class="keyword">void</span></code>. + </p> +<p> + <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"><span class="preprocessor">#include</span> + <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_pre_decrement</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_operator</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + </p> +<p> + <span class="bold"><strong>Examples:</strong></span> + </p> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_pre_decrement</span><span class="special"><</span><span class="identifier">Rhs</span><span class="special">,</span> <span class="identifier">Ret</span><span class="special">>::</span><span class="identifier">value_type</span></code> is the type <code class="computeroutput"><span class="keyword">bool</span></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_pre_decrement</span><span class="special"><</span><span class="identifier">Rhs</span><span class="special">,</span> <span class="identifier">Ret</span><span class="special">>::</span><span class="identifier">value</span></code> is a <code class="computeroutput"><span class="keyword">bool</span></code> + integral constant expression. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_pre_decrement</span><span class="special"><</span><span class="keyword">int</span><span class="special">>::</span><span class="identifier">value</span></code> is a <code class="computeroutput"><span class="keyword">bool</span></code> + integral constant expression that evaluates to <code class="computeroutput"><span class="keyword">true</span></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_pre_decrement</span><span class="special"><</span><span class="keyword">long</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_pre_decrement</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_pre_decrement</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">long</span><span class="special">></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_pre_decrement</span><span class="special"><</span><span class="keyword">double</span><span class="special">,</span> <span class="keyword">double</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_pre_decrement</span><span class="special"><</span><span class="keyword">double</span><span class="special">,</span> <span class="keyword">int</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_pre_decrement</span><span class="special"><</span><span class="keyword">bool</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_pre_decrement</span><span class="special"><</span><span class="keyword">const</span> <span class="keyword">int</span><span class="special">></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_pre_decrement</span><span class="special"><</span><span class="keyword">void</span><span class="special">*></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_pre_decrement</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>. + </p></blockquote></div> +<p> + <span class="bold"><strong>See also:</strong></span> <a class="link" href="../category/value_traits/operators.html" title="Operator Type Traits">Operator + Type Traits</a> + </p> +<p> + <span class="bold"><strong>Limitation:</strong></span> + </p> +<div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"> + Requires a compiler with working SFINAE. + </li></ul></div> +<p> + <span class="bold"><strong>Known issues:</strong></span> + </p> +<div class="itemizedlist"><ul class="itemizedlist" type="disc"> +<li class="listitem"> + This trait cannot detect whether prefix <code class="computeroutput"><span class="keyword">operator</span><span class="special">--</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">--</span></code> + is defined as a private member of <code class="computeroutput"><span class="identifier">Rhs</span></code> + then instantiating <code class="computeroutput"><span class="identifier">has_pre_decrement</span><span class="special"><</span><span class="identifier">Rhs</span><span class="special">></span></code> will produce a compiler error. For + this reason <code class="computeroutput"><span class="identifier">has_pre_decrement</span></code> + cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">--</span></code> + or not. +<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">--();</span> <span class="special">};</span> +<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_pre_decrement</span><span class="special"><</span><span class="identifier">A</span><span class="special">>::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator--() is private</span> +</pre> + </li> +<li class="listitem"> + There is an issue if the operator exists only for type <code class="computeroutput"><span class="identifier">A</span></code> and <code class="computeroutput"><span class="identifier">B</span></code> + is convertible to <code class="computeroutput"><span class="identifier">A</span></code>. + In this case, the compiler will report an ambiguous overload. +<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span> +<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">--(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&);</span> +<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span> +<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_pre_decrement</span><span class="special"><</span><span class="identifier">A</span><span class="special">>::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine</span> +<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_pre_decrement</span><span class="special"><</span><span class="identifier">B</span><span class="special">>::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambiguous overload</span> +</pre> + </li> +<li class="listitem"> + There is an issue when applying this trait to template classes. If <code class="computeroutput"><span class="keyword">operator</span><span class="special">--</span></code> + is defined but does not bind for a given template type, it is still detected + by the trait which returns <code class="computeroutput"><span class="keyword">true</span></code> + instead of <code class="computeroutput"><span class="keyword">false</span></code>. Example: + +<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_pre_decrement</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span> +<span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">iostream</span><span class="special">></span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">contains</span> <span class="special">{</span> <span class="identifier">T</span> <span class="identifier">data</span><span class="special">;</span> <span class="special">};</span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">--(</span><span class="keyword">const</span> <span class="identifier">contains</span><span class="special"><</span><span class="identifier">T</span><span class="special">></span> <span class="special">&</span><span class="identifier">rhs</span><span class="special">)</span> <span class="special">{</span> + <span class="keyword">return</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">rhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">);</span> +<span class="special">}</span> + +<span class="keyword">class</span> <span class="identifier">bad</span> <span class="special">{</span> <span class="special">};</span> +<span class="keyword">class</span> <span class="identifier">good</span> <span class="special">{</span> <span class="special">};</span> +<span class="keyword">bool</span> <span class="identifier">f</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">good</span><span class="special">&)</span> <span class="special">{</span> <span class="special">}</span> + +<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span> <span class="special">{</span> + <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special"><<</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">boolalpha</span><span class="special">;</span> + <span class="comment">// works fine for contains<good></span> + <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special"><<</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_pre_decrement</span><span class="special"><</span> <span class="identifier">contains</span><span class="special"><</span> <span class="identifier">good</span> <span class="special">></span> <span class="special">>::</span><span class="identifier">value</span><span class="special"><<</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true</span> + <span class="identifier">contains</span><span class="special"><</span><span class="identifier">good</span><span class="special">></span> <span class="identifier">g</span><span class="special">;</span> + <span class="special">--</span><span class="identifier">g</span><span class="special">;</span> <span class="comment">// ok</span> + <span class="comment">// does not work for contains<bad></span> + <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special"><<</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_pre_decrement</span><span class="special"><</span> <span class="identifier">contains</span><span class="special"><</span> <span class="identifier">bad</span> <span class="special">></span> <span class="special">>::</span><span class="identifier">value</span><span class="special"><<</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true, should be false</span> + <span class="identifier">contains</span><span class="special"><</span><span class="identifier">bad</span><span class="special">></span> <span class="identifier">b</span><span class="special">;</span> + <span class="special">--</span><span class="identifier">b</span><span class="special">;</span> <span class="comment">// compile time error</span> + <span class="keyword">return</span> <span class="number">0</span><span class="special">;</span> +<span class="special">}</span> +</pre> + </li> +<li class="listitem"> + <code class="computeroutput"><span class="keyword">volatile</span></code> qualifier is not + properly handled and would lead to undefined behavior + </li> +</ul></div> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="has_post_increment.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="has_pre_increment.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/reference/has_pre_increment.html b/libs/type_traits/doc/html/boost_typetraits/reference/has_pre_increment.html new file mode 100644 index 0000000000..01818da4fc --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/reference/has_pre_increment.html @@ -0,0 +1,205 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>has_pre_increment</title> +<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../reference.html" title="Alphabetical Reference"> +<link rel="prev" href="has_pre_decrement.html" title="has_pre_decrement"> +<link rel="next" href="has_right_shift.html" title="has_right_shift"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td> +<td align="center"><a href="../../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="has_pre_decrement.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="has_right_shift.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h3 class="title"> +<a name="boost_typetraits.reference.has_pre_increment"></a><a class="link" href="has_pre_increment.html" title="has_pre_increment">has_pre_increment</a> +</h3></div></div></div> +<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">Rhs</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Ret</span><span class="special">=</span><span class="identifier">dont_care</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">has_pre_increment</span> <span class="special">:</span> <span class="keyword">public</span> <em class="replaceable"><code><a class="link" href="integral_constant.html" title="integral_constant">true_type</a>-or-<a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code></em> <span class="special">{};</span> +</pre> +<p> + <span class="bold"><strong>Inherits:</strong></span> If (i) <code class="computeroutput"><span class="identifier">rhs</span></code> + of type <code class="computeroutput"><span class="identifier">Rhs</span></code> can be used in + expression <code class="computeroutput"><span class="special">++</span><span class="identifier">rhs</span></code>, + and (ii) <code class="computeroutput"><span class="identifier">Ret</span><span class="special">=</span><span class="identifier">dont_care</span></code> or the result of expression + <code class="computeroutput"><span class="special">++</span><span class="identifier">rhs</span></code> + is convertible to <code class="computeroutput"><span class="identifier">Ret</span></code> then + inherits from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>, + otherwise inherits from <a class="link" href="integral_constant.html" title="integral_constant">false_type</a>. + </p> +<p> + The default behaviour (<code class="computeroutput"><span class="identifier">Ret</span><span class="special">=</span><span class="identifier">dont_care</span></code>) + is to not check for the return value of prefix <code class="computeroutput"><span class="keyword">operator</span><span class="special">++</span></code>. If <code class="computeroutput"><span class="identifier">Ret</span></code> + is different from the default <code class="computeroutput"><span class="identifier">dont_care</span></code> + type, the return value is checked to be convertible to <code class="computeroutput"><span class="identifier">Ret</span></code>. + Convertible to <code class="computeroutput"><span class="identifier">Ret</span></code> means + that the return value of the operator can be used as argument to a function + expecting <code class="computeroutput"><span class="identifier">Ret</span></code>: +</p> +<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">Ret</span><span class="special">);</span> +<span class="identifier">Rhs</span> <span class="identifier">rhs</span><span class="special">;</span> +<span class="identifier">f</span><span class="special">(++</span><span class="identifier">rhs</span><span class="special">);</span> <span class="comment">// is valid if has_pre_increment<Rhs, Ret>::value==true</span> +</pre> +<p> + If <code class="computeroutput"><span class="identifier">Ret</span><span class="special">=</span><span class="keyword">void</span></code>, the return type is checked to be exactly + <code class="computeroutput"><span class="keyword">void</span></code>. + </p> +<p> + <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"><span class="preprocessor">#include</span> + <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_pre_increment</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_operator</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + </p> +<p> + <span class="bold"><strong>Examples:</strong></span> + </p> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_pre_increment</span><span class="special"><</span><span class="identifier">Rhs</span><span class="special">,</span> <span class="identifier">Ret</span><span class="special">>::</span><span class="identifier">value_type</span></code> is the type <code class="computeroutput"><span class="keyword">bool</span></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_pre_increment</span><span class="special"><</span><span class="identifier">Rhs</span><span class="special">,</span> <span class="identifier">Ret</span><span class="special">>::</span><span class="identifier">value</span></code> is a <code class="computeroutput"><span class="keyword">bool</span></code> + integral constant expression. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_pre_increment</span><span class="special"><</span><span class="keyword">int</span><span class="special">>::</span><span class="identifier">value</span></code> is a <code class="computeroutput"><span class="keyword">bool</span></code> + integral constant expression that evaluates to <code class="computeroutput"><span class="keyword">true</span></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_pre_increment</span><span class="special"><</span><span class="keyword">long</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_pre_increment</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_pre_increment</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">long</span><span class="special">></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_pre_increment</span><span class="special"><</span><span class="keyword">double</span><span class="special">,</span> <span class="keyword">double</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_pre_increment</span><span class="special"><</span><span class="keyword">double</span><span class="special">,</span> <span class="keyword">int</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_pre_increment</span><span class="special"><</span><span class="keyword">bool</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_pre_increment</span><span class="special"><</span><span class="keyword">const</span> <span class="keyword">int</span><span class="special">></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_pre_increment</span><span class="special"><</span><span class="keyword">void</span><span class="special">*></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_pre_increment</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>. + </p></blockquote></div> +<p> + <span class="bold"><strong>See also:</strong></span> <a class="link" href="../category/value_traits/operators.html" title="Operator Type Traits">Operator + Type Traits</a> + </p> +<p> + <span class="bold"><strong>Limitation:</strong></span> + </p> +<div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"> + Requires a compiler with working SFINAE. + </li></ul></div> +<p> + <span class="bold"><strong>Known issues:</strong></span> + </p> +<div class="itemizedlist"><ul class="itemizedlist" type="disc"> +<li class="listitem"> + This trait cannot detect whether prefix <code class="computeroutput"><span class="keyword">operator</span><span class="special">++</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">++</span></code> + is defined as a private member of <code class="computeroutput"><span class="identifier">Rhs</span></code> + then instantiating <code class="computeroutput"><span class="identifier">has_pre_increment</span><span class="special"><</span><span class="identifier">Rhs</span><span class="special">></span></code> will produce a compiler error. For + this reason <code class="computeroutput"><span class="identifier">has_pre_increment</span></code> + cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">++</span></code> + or not. +<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">++();</span> <span class="special">};</span> +<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_pre_increment</span><span class="special"><</span><span class="identifier">A</span><span class="special">>::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator++() is private</span> +</pre> + </li> +<li class="listitem"> + There is an issue if the operator exists only for type <code class="computeroutput"><span class="identifier">A</span></code> and <code class="computeroutput"><span class="identifier">B</span></code> + is convertible to <code class="computeroutput"><span class="identifier">A</span></code>. + In this case, the compiler will report an ambiguous overload. +<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span> +<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">++(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&);</span> +<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span> +<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_pre_increment</span><span class="special"><</span><span class="identifier">A</span><span class="special">>::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine</span> +<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_pre_increment</span><span class="special"><</span><span class="identifier">B</span><span class="special">>::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambiguous overload</span> +</pre> + </li> +<li class="listitem"> + There is an issue when applying this trait to template classes. If <code class="computeroutput"><span class="keyword">operator</span><span class="special">++</span></code> + is defined but does not bind for a given template type, it is still detected + by the trait which returns <code class="computeroutput"><span class="keyword">true</span></code> + instead of <code class="computeroutput"><span class="keyword">false</span></code>. Example: + +<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_pre_increment</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span> +<span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">iostream</span><span class="special">></span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">contains</span> <span class="special">{</span> <span class="identifier">T</span> <span class="identifier">data</span><span class="special">;</span> <span class="special">};</span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">++(</span><span class="keyword">const</span> <span class="identifier">contains</span><span class="special"><</span><span class="identifier">T</span><span class="special">></span> <span class="special">&</span><span class="identifier">rhs</span><span class="special">)</span> <span class="special">{</span> + <span class="keyword">return</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">rhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">);</span> +<span class="special">}</span> + +<span class="keyword">class</span> <span class="identifier">bad</span> <span class="special">{</span> <span class="special">};</span> +<span class="keyword">class</span> <span class="identifier">good</span> <span class="special">{</span> <span class="special">};</span> +<span class="keyword">bool</span> <span class="identifier">f</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">good</span><span class="special">&)</span> <span class="special">{</span> <span class="special">}</span> + +<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span> <span class="special">{</span> + <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special"><<</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">boolalpha</span><span class="special">;</span> + <span class="comment">// works fine for contains<good></span> + <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special"><<</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_pre_increment</span><span class="special"><</span> <span class="identifier">contains</span><span class="special"><</span> <span class="identifier">good</span> <span class="special">></span> <span class="special">>::</span><span class="identifier">value</span><span class="special"><<</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true</span> + <span class="identifier">contains</span><span class="special"><</span><span class="identifier">good</span><span class="special">></span> <span class="identifier">g</span><span class="special">;</span> + <span class="special">++</span><span class="identifier">g</span><span class="special">;</span> <span class="comment">// ok</span> + <span class="comment">// does not work for contains<bad></span> + <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special"><<</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_pre_increment</span><span class="special"><</span> <span class="identifier">contains</span><span class="special"><</span> <span class="identifier">bad</span> <span class="special">></span> <span class="special">>::</span><span class="identifier">value</span><span class="special"><<</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true, should be false</span> + <span class="identifier">contains</span><span class="special"><</span><span class="identifier">bad</span><span class="special">></span> <span class="identifier">b</span><span class="special">;</span> + <span class="special">++</span><span class="identifier">b</span><span class="special">;</span> <span class="comment">// compile time error</span> + <span class="keyword">return</span> <span class="number">0</span><span class="special">;</span> +<span class="special">}</span> +</pre> + </li> +<li class="listitem"> + <code class="computeroutput"><span class="keyword">volatile</span></code> qualifier is not + properly handled and would lead to undefined behavior + </li> +</ul></div> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="has_pre_decrement.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="has_right_shift.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/reference/has_right_shift.html b/libs/type_traits/doc/html/boost_typetraits/reference/has_right_shift.html new file mode 100644 index 0000000000..b3185b2be4 --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/reference/has_right_shift.html @@ -0,0 +1,204 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>has_right_shift</title> +<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../reference.html" title="Alphabetical Reference"> +<link rel="prev" href="has_pre_increment.html" title="has_pre_increment"> +<link rel="next" href="has_right_shift_assign.html" title="has_right_shift_assign"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td> +<td align="center"><a href="../../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="has_pre_increment.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="has_right_shift_assign.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h3 class="title"> +<a name="boost_typetraits.reference.has_right_shift"></a><a class="link" href="has_right_shift.html" title="has_right_shift">has_right_shift</a> +</h3></div></div></div> +<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">Lhs</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Rhs</span><span class="special">=</span><span class="identifier">Lhs</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Ret</span><span class="special">=</span><span class="identifier">dont_care</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">has_right_shift</span> <span class="special">:</span> <span class="keyword">public</span> <em class="replaceable"><code><a class="link" href="integral_constant.html" title="integral_constant">true_type</a>-or-<a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code></em> <span class="special">{};</span> +</pre> +<p> + <span class="bold"><strong>Inherits:</strong></span> If (i) <code class="computeroutput"><span class="identifier">lhs</span></code> + of type <code class="computeroutput"><span class="identifier">Lhs</span></code> and <code class="computeroutput"><span class="identifier">rhs</span></code> of type <code class="computeroutput"><span class="identifier">Rhs</span></code> + can be used in expression <code class="computeroutput"><span class="identifier">lhs</span><span class="special">>></span><span class="identifier">rhs</span></code>, + and (ii) <code class="computeroutput"><span class="identifier">Ret</span><span class="special">=</span><span class="identifier">dont_care</span></code> or the result of expression + <code class="computeroutput"><span class="identifier">lhs</span><span class="special">>></span><span class="identifier">rhs</span></code> is convertible to <code class="computeroutput"><span class="identifier">Ret</span></code> + then inherits from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>, + otherwise inherits from <a class="link" href="integral_constant.html" title="integral_constant">false_type</a>. + </p> +<p> + The default behaviour (<code class="computeroutput"><span class="identifier">Ret</span><span class="special">=</span><span class="identifier">dont_care</span></code>) + is to not check for the return value of binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">>></span></code>. If <code class="computeroutput"><span class="identifier">Ret</span></code> + is different from the default <code class="computeroutput"><span class="identifier">dont_care</span></code> + type, the return value is checked to be convertible to <code class="computeroutput"><span class="identifier">Ret</span></code>. + Convertible to <code class="computeroutput"><span class="identifier">Ret</span></code> means + that the return value of the operator can be used as argument to a function + expecting <code class="computeroutput"><span class="identifier">Ret</span></code>: +</p> +<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">Ret</span><span class="special">);</span> +<span class="identifier">Lhs</span> <span class="identifier">lhs</span><span class="special">;</span> +<span class="identifier">Rhs</span> <span class="identifier">rhs</span><span class="special">;</span> +<span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">>></span><span class="identifier">rhs</span><span class="special">);</span> <span class="comment">// is valid if has_right_shift<Lhs, Rhs, Ret>::value==true</span> +</pre> +<p> + If <code class="computeroutput"><span class="identifier">Ret</span><span class="special">=</span><span class="keyword">void</span></code>, the return type is checked to be exactly + <code class="computeroutput"><span class="keyword">void</span></code>. + </p> +<p> + <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"><span class="preprocessor">#include</span> + <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_right_shift</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_operator</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + </p> +<p> + <span class="bold"><strong>Examples:</strong></span> + </p> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_right_shift</span><span class="special"><</span><span class="identifier">Lhs</span><span class="special">,</span> <span class="identifier">Rhs</span><span class="special">,</span> <span class="identifier">Ret</span><span class="special">>::</span><span class="identifier">value_type</span></code> is the type <code class="computeroutput"><span class="keyword">bool</span></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_right_shift</span><span class="special"><</span><span class="identifier">Lhs</span><span class="special">,</span> <span class="identifier">Rhs</span><span class="special">,</span> <span class="identifier">Ret</span><span class="special">>::</span><span class="identifier">value</span></code> is a <code class="computeroutput"><span class="keyword">bool</span></code> + integral constant expression. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_right_shift</span><span class="special"><</span><span class="keyword">int</span><span class="special">>::</span><span class="identifier">value</span></code> is a <code class="computeroutput"><span class="keyword">bool</span></code> + integral constant expression that evaluates to <code class="computeroutput"><span class="keyword">true</span></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_right_shift</span><span class="special"><</span><span class="keyword">long</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_right_shift</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_right_shift</span><span class="special"><</span><span class="keyword">const</span> <span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_right_shift</span><span class="special"><</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">istream</span><span class="special">,</span> <span class="keyword">int</span><span class="special">&></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_right_shift</span><span class="special"><</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">istream</span><span class="special">,</span> <span class="keyword">char</span><span class="special">*,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">ostream</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_right_shift</span><span class="special"><</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">istream</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_right_shift</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">bool</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_right_shift</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>. + </p></blockquote></div> +<p> + <span class="bold"><strong>See also:</strong></span> <a class="link" href="../category/value_traits/operators.html" title="Operator Type Traits">Operator + Type Traits</a> + </p> +<p> + <span class="bold"><strong>Limitation:</strong></span> + </p> +<div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"> + Requires a compiler with working SFINAE. + </li></ul></div> +<p> + <span class="bold"><strong>Known issues:</strong></span> + </p> +<div class="itemizedlist"><ul class="itemizedlist" type="disc"> +<li class="listitem"> + This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">>></span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">>></span></code> + is defined as a private member of <code class="computeroutput"><span class="identifier">Lhs</span></code> + then instantiating <code class="computeroutput"><span class="identifier">has_right_shift</span><span class="special"><</span><span class="identifier">Lhs</span><span class="special">></span></code> will produce a compiler error. For + this reason <code class="computeroutput"><span class="identifier">has_right_shift</span></code> + cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">>></span></code> + or not. +<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">>>(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&);</span> <span class="special">};</span> +<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_right_shift</span><span class="special"><</span><span class="identifier">A</span><span class="special">>::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator>>(const A&) is private</span> +</pre> + </li> +<li class="listitem"> + There is an issue if the operator exists only for type <code class="computeroutput"><span class="identifier">A</span></code> and <code class="computeroutput"><span class="identifier">B</span></code> + is convertible to <code class="computeroutput"><span class="identifier">A</span></code>. + In this case, the compiler will report an ambiguous overload. +<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span> +<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">>>(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&,</span> <span class="keyword">const</span> <span class="identifier">A</span><span class="special">&);</span> +<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span> +<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_right_shift</span><span class="special"><</span><span class="identifier">A</span><span class="special">>::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine</span> +<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_right_shift</span><span class="special"><</span><span class="identifier">B</span><span class="special">>::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambiguous overload</span> +</pre> + </li> +<li class="listitem"> + There is an issue when applying this trait to template classes. If <code class="computeroutput"><span class="keyword">operator</span><span class="special">>></span></code> + is defined but does not bind for a given template type, it is still detected + by the trait which returns <code class="computeroutput"><span class="keyword">true</span></code> + instead of <code class="computeroutput"><span class="keyword">false</span></code>. Example: + +<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_right_shift</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span> +<span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">iostream</span><span class="special">></span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">contains</span> <span class="special">{</span> <span class="identifier">T</span> <span class="identifier">data</span><span class="special">;</span> <span class="special">};</span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">>>(</span><span class="keyword">const</span> <span class="identifier">contains</span><span class="special"><</span><span class="identifier">T</span><span class="special">></span> <span class="special">&</span><span class="identifier">lhs</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">contains</span><span class="special"><</span><span class="identifier">T</span><span class="special">></span> <span class="special">&</span><span class="identifier">rhs</span><span class="special">)</span> <span class="special">{</span> + <span class="keyword">return</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">,</span> <span class="identifier">rhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">);</span> +<span class="special">}</span> + +<span class="keyword">class</span> <span class="identifier">bad</span> <span class="special">{</span> <span class="special">};</span> +<span class="keyword">class</span> <span class="identifier">good</span> <span class="special">{</span> <span class="special">};</span> +<span class="keyword">bool</span> <span class="identifier">f</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">good</span><span class="special">&,</span> <span class="keyword">const</span> <span class="identifier">good</span><span class="special">&)</span> <span class="special">{</span> <span class="special">}</span> + +<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span> <span class="special">{</span> + <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special"><<</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">boolalpha</span><span class="special">;</span> + <span class="comment">// works fine for contains<good></span> + <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special"><<</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_right_shift</span><span class="special"><</span> <span class="identifier">contains</span><span class="special"><</span> <span class="identifier">good</span> <span class="special">></span> <span class="special">>::</span><span class="identifier">value</span><span class="special"><<</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true</span> + <span class="identifier">contains</span><span class="special"><</span><span class="identifier">good</span><span class="special">></span> <span class="identifier">g</span><span class="special">;</span> + <span class="identifier">g</span><span class="special">>></span><span class="identifier">g</span><span class="special">;</span> <span class="comment">// ok</span> + <span class="comment">// does not work for contains<bad></span> + <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special"><<</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_right_shift</span><span class="special"><</span> <span class="identifier">contains</span><span class="special"><</span> <span class="identifier">bad</span> <span class="special">></span> <span class="special">>::</span><span class="identifier">value</span><span class="special"><<</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true, should be false</span> + <span class="identifier">contains</span><span class="special"><</span><span class="identifier">bad</span><span class="special">></span> <span class="identifier">b</span><span class="special">;</span> + <span class="identifier">b</span><span class="special">>></span><span class="identifier">b</span><span class="special">;</span> <span class="comment">// compile time error</span> + <span class="keyword">return</span> <span class="number">0</span><span class="special">;</span> +<span class="special">}</span> +</pre> + </li> +<li class="listitem"> + <code class="computeroutput"><span class="keyword">volatile</span></code> qualifier is not + properly handled and would lead to undefined behavior + </li> +</ul></div> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="has_pre_increment.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="has_right_shift_assign.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/reference/has_right_shift_assign.html b/libs/type_traits/doc/html/boost_typetraits/reference/has_right_shift_assign.html new file mode 100644 index 0000000000..0411afb36a --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/reference/has_right_shift_assign.html @@ -0,0 +1,196 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>has_right_shift_assign</title> +<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../reference.html" title="Alphabetical Reference"> +<link rel="prev" href="has_right_shift.html" title="has_right_shift"> +<link rel="next" href="has_trivial_assign.html" title="has_trivial_assign"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td> +<td align="center"><a href="../../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="has_right_shift.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="has_trivial_assign.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h3 class="title"> +<a name="boost_typetraits.reference.has_right_shift_assign"></a><a class="link" href="has_right_shift_assign.html" title="has_right_shift_assign">has_right_shift_assign</a> +</h3></div></div></div> +<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">Lhs</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Rhs</span><span class="special">=</span><span class="identifier">Lhs</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Ret</span><span class="special">=</span><span class="identifier">dont_care</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">has_right_shift_assign</span> <span class="special">:</span> <span class="keyword">public</span> <em class="replaceable"><code><a class="link" href="integral_constant.html" title="integral_constant">true_type</a>-or-<a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code></em> <span class="special">{};</span> +</pre> +<p> + <span class="bold"><strong>Inherits:</strong></span> If (i) <code class="computeroutput"><span class="identifier">lhs</span></code> + of type <code class="computeroutput"><span class="identifier">Lhs</span></code> and <code class="computeroutput"><span class="identifier">rhs</span></code> of type <code class="computeroutput"><span class="identifier">Rhs</span></code> + can be used in expression <code class="computeroutput"><span class="identifier">lhs</span><span class="special">>>=</span><span class="identifier">rhs</span></code>, + and (ii) <code class="computeroutput"><span class="identifier">Ret</span><span class="special">=</span><span class="identifier">dont_care</span></code> or the result of expression + <code class="computeroutput"><span class="identifier">lhs</span><span class="special">>>=</span><span class="identifier">rhs</span></code> is convertible to <code class="computeroutput"><span class="identifier">Ret</span></code> + then inherits from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>, + otherwise inherits from <a class="link" href="integral_constant.html" title="integral_constant">false_type</a>. + </p> +<p> + The default behaviour (<code class="computeroutput"><span class="identifier">Ret</span><span class="special">=</span><span class="identifier">dont_care</span></code>) + is to not check for the return value of binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">>>=</span></code>. If <code class="computeroutput"><span class="identifier">Ret</span></code> + is different from the default <code class="computeroutput"><span class="identifier">dont_care</span></code> + type, the return value is checked to be convertible to <code class="computeroutput"><span class="identifier">Ret</span></code>. + Convertible to <code class="computeroutput"><span class="identifier">Ret</span></code> means + that the return value of the operator can be used as argument to a function + expecting <code class="computeroutput"><span class="identifier">Ret</span></code>: +</p> +<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">Ret</span><span class="special">);</span> +<span class="identifier">Lhs</span> <span class="identifier">lhs</span><span class="special">;</span> +<span class="identifier">Rhs</span> <span class="identifier">rhs</span><span class="special">;</span> +<span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">>>=</span><span class="identifier">rhs</span><span class="special">);</span> <span class="comment">// is valid if has_right_shift_assign<Lhs, Rhs, Ret>::value==true</span> +</pre> +<p> + If <code class="computeroutput"><span class="identifier">Ret</span><span class="special">=</span><span class="keyword">void</span></code>, the return type is checked to be exactly + <code class="computeroutput"><span class="keyword">void</span></code>. + </p> +<p> + <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"><span class="preprocessor">#include</span> + <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_right_shift_assign</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_operator</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + </p> +<p> + <span class="bold"><strong>Examples:</strong></span> + </p> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_right_shift_assign</span><span class="special"><</span><span class="identifier">Lhs</span><span class="special">,</span> <span class="identifier">Rhs</span><span class="special">,</span> <span class="identifier">Ret</span><span class="special">>::</span><span class="identifier">value_type</span></code> + is the type <code class="computeroutput"><span class="keyword">bool</span></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_right_shift_assign</span><span class="special"><</span><span class="identifier">Lhs</span><span class="special">,</span> <span class="identifier">Rhs</span><span class="special">,</span> <span class="identifier">Ret</span><span class="special">>::</span><span class="identifier">value</span></code> + is a <code class="computeroutput"><span class="keyword">bool</span></code> integral constant + expression. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_right_shift_assign</span><span class="special"><</span><span class="keyword">int</span><span class="special">>::</span><span class="identifier">value</span></code> + is a <code class="computeroutput"><span class="keyword">bool</span></code> integral constant + expression that evaluates to <code class="computeroutput"><span class="keyword">true</span></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_right_shift_assign</span><span class="special"><</span><span class="keyword">long</span><span class="special">></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_right_shift_assign</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> + <span class="keyword">int</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_right_shift_assign</span><span class="special"><</span><span class="keyword">const</span> <span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_right_shift_assign</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">bool</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_right_shift_assign</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> + <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>. + </p></blockquote></div> +<p> + <span class="bold"><strong>See also:</strong></span> <a class="link" href="../category/value_traits/operators.html" title="Operator Type Traits">Operator + Type Traits</a> + </p> +<p> + <span class="bold"><strong>Limitation:</strong></span> + </p> +<div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"> + Requires a compiler with working SFINAE. + </li></ul></div> +<p> + <span class="bold"><strong>Known issues:</strong></span> + </p> +<div class="itemizedlist"><ul class="itemizedlist" type="disc"> +<li class="listitem"> + This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">>>=</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">>>=</span></code> + is defined as a private member of <code class="computeroutput"><span class="identifier">Lhs</span></code> + then instantiating <code class="computeroutput"><span class="identifier">has_right_shift_assign</span><span class="special"><</span><span class="identifier">Lhs</span><span class="special">></span></code> will produce a compiler error. For + this reason <code class="computeroutput"><span class="identifier">has_right_shift_assign</span></code> + cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">>>=</span></code> + or not. +<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">>>=(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&);</span> <span class="special">};</span> +<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_right_shift_assign</span><span class="special"><</span><span class="identifier">A</span><span class="special">>::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator>>=(const A&) is private</span> +</pre> + </li> +<li class="listitem"> + There is an issue if the operator exists only for type <code class="computeroutput"><span class="identifier">A</span></code> and <code class="computeroutput"><span class="identifier">B</span></code> + is convertible to <code class="computeroutput"><span class="identifier">A</span></code>. + In this case, the compiler will report an ambiguous overload. +<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span> +<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">>>=(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&,</span> <span class="keyword">const</span> <span class="identifier">A</span><span class="special">&);</span> +<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span> +<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_right_shift_assign</span><span class="special"><</span><span class="identifier">A</span><span class="special">>::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine</span> +<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_right_shift_assign</span><span class="special"><</span><span class="identifier">B</span><span class="special">>::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambiguous overload</span> +</pre> + </li> +<li class="listitem"> + There is an issue when applying this trait to template classes. If <code class="computeroutput"><span class="keyword">operator</span><span class="special">>>=</span></code> + is defined but does not bind for a given template type, it is still detected + by the trait which returns <code class="computeroutput"><span class="keyword">true</span></code> + instead of <code class="computeroutput"><span class="keyword">false</span></code>. Example: + +<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_right_shift_assign</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span> +<span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">iostream</span><span class="special">></span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">contains</span> <span class="special">{</span> <span class="identifier">T</span> <span class="identifier">data</span><span class="special">;</span> <span class="special">};</span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">>>=(</span><span class="keyword">const</span> <span class="identifier">contains</span><span class="special"><</span><span class="identifier">T</span><span class="special">></span> <span class="special">&</span><span class="identifier">lhs</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">contains</span><span class="special"><</span><span class="identifier">T</span><span class="special">></span> <span class="special">&</span><span class="identifier">rhs</span><span class="special">)</span> <span class="special">{</span> + <span class="keyword">return</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">,</span> <span class="identifier">rhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">);</span> +<span class="special">}</span> + +<span class="keyword">class</span> <span class="identifier">bad</span> <span class="special">{</span> <span class="special">};</span> +<span class="keyword">class</span> <span class="identifier">good</span> <span class="special">{</span> <span class="special">};</span> +<span class="keyword">bool</span> <span class="identifier">f</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">good</span><span class="special">&,</span> <span class="keyword">const</span> <span class="identifier">good</span><span class="special">&)</span> <span class="special">{</span> <span class="special">}</span> + +<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span> <span class="special">{</span> + <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special"><<</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">boolalpha</span><span class="special">;</span> + <span class="comment">// works fine for contains<good></span> + <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special"><<</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_right_shift_assign</span><span class="special"><</span> <span class="identifier">contains</span><span class="special"><</span> <span class="identifier">good</span> <span class="special">></span> <span class="special">>::</span><span class="identifier">value</span><span class="special"><<</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true</span> + <span class="identifier">contains</span><span class="special"><</span><span class="identifier">good</span><span class="special">></span> <span class="identifier">g</span><span class="special">;</span> + <span class="identifier">g</span><span class="special">>>=</span><span class="identifier">g</span><span class="special">;</span> <span class="comment">// ok</span> + <span class="comment">// does not work for contains<bad></span> + <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special"><<</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_right_shift_assign</span><span class="special"><</span> <span class="identifier">contains</span><span class="special"><</span> <span class="identifier">bad</span> <span class="special">></span> <span class="special">>::</span><span class="identifier">value</span><span class="special"><<</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true, should be false</span> + <span class="identifier">contains</span><span class="special"><</span><span class="identifier">bad</span><span class="special">></span> <span class="identifier">b</span><span class="special">;</span> + <span class="identifier">b</span><span class="special">>>=</span><span class="identifier">b</span><span class="special">;</span> <span class="comment">// compile time error</span> + <span class="keyword">return</span> <span class="number">0</span><span class="special">;</span> +<span class="special">}</span> +</pre> + </li> +<li class="listitem"> + <code class="computeroutput"><span class="keyword">volatile</span></code> qualifier is not + properly handled and would lead to undefined behavior + </li> +</ul></div> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="has_right_shift.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="has_trivial_assign.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/reference/has_trivial_assign.html b/libs/type_traits/doc/html/boost_typetraits/reference/has_trivial_assign.html new file mode 100644 index 0000000000..db769c787a --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/reference/has_trivial_assign.html @@ -0,0 +1,105 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>has_trivial_assign</title> +<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../reference.html" title="Alphabetical Reference"> +<link rel="prev" href="has_right_shift_assign.html" title="has_right_shift_assign"> +<link rel="next" href="has_trivial_constructor.html" title="has_trivial_constructor"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td> +<td align="center"><a href="../../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="has_right_shift_assign.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="has_trivial_constructor.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h3 class="title"> +<a name="boost_typetraits.reference.has_trivial_assign"></a><a class="link" href="has_trivial_assign.html" title="has_trivial_assign">has_trivial_assign</a> +</h3></div></div></div> +<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">has_trivial_assign</span> <span class="special">:</span> <span class="keyword">public</span> <em class="replaceable"><code><a class="link" href="integral_constant.html" title="integral_constant">true_type</a>-or-<a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code></em> <span class="special">{};</span> +</pre> +<p> + <span class="bold"><strong>Inherits:</strong></span> If T is a (possibly cv-qualified) + type with a trivial assignment-operator then inherits from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>, + otherwise inherits from <a class="link" href="integral_constant.html" title="integral_constant">false_type</a>. + </p> +<p> + 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 <code class="computeroutput"><span class="identifier">memcpy</span></code>. + </p> +<p> + <span class="bold"><strong>Compiler Compatibility:</strong></span> If the compiler + does not support partial-specialization of class templates, then this template + can not be used with function types. + </p> +<p> + 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 2011) compilers + more recent than Visual C++ 8, GCC-4.3, Greenhills 6.0, Intel-11.0, and Codegear + have the necessary compiler <a class="link" href="../intrinsics.html" title="Support for Compiler Intrinsics">intrinsics</a> + to ensure that this trait "just works". You may also test to see + if the necessary <a class="link" href="../intrinsics.html" title="Support for Compiler Intrinsics">intrinsics</a> + are available by checking to see if the macro <code class="computeroutput"><span class="identifier">BOOST_HAS_TRIVIAL_ASSIGN</span></code> + is defined. + </p> +<p> + <span class="bold"><strong>C++ Standard Reference:</strong></span> 12.8p11. + </p> +<p> + <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"> <span class="preprocessor">#include</span> + <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_trivial_assign</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + </p> +<p> + <span class="bold"><strong>Examples:</strong></span> + </p> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_trivial_assign</span><span class="special"><</span><span class="keyword">int</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_trivial_assign</span><span class="special"><</span><span class="keyword">char</span><span class="special">*>::</span><span class="identifier">type</span></code> is the type <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_trivial_assign</span><span class="special"><</span><span class="keyword">int</span> <span class="special">(*)(</span><span class="keyword">long</span><span class="special">)>::</span><span class="identifier">value</span></code> is an integral constant expression + that evaluates to <span class="emphasis"><em>true</em></span>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_trivial_assign</span><span class="special"><</span><span class="identifier">MyClass</span><span class="special">>::</span><span class="identifier">value</span></code> is an integral constant expression + that evaluates to <span class="emphasis"><em>false</em></span>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_trivial_assign</span><span class="special"><</span><span class="identifier">T</span><span class="special">>::</span><span class="identifier">value_type</span></code> is the type <code class="computeroutput"><span class="keyword">bool</span></code>. + </p></blockquote></div> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="has_right_shift_assign.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="has_trivial_constructor.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/reference/has_trivial_constructor.html b/libs/type_traits/doc/html/boost_typetraits/reference/has_trivial_constructor.html new file mode 100644 index 0000000000..e27e7210ab --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/reference/has_trivial_constructor.html @@ -0,0 +1,114 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>has_trivial_constructor</title> +<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../reference.html" title="Alphabetical Reference"> +<link rel="prev" href="has_trivial_assign.html" title="has_trivial_assign"> +<link rel="next" href="has_trivial_copy.html" title="has_trivial_copy"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td> +<td align="center"><a href="../../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="has_trivial_assign.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="has_trivial_copy.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h3 class="title"> +<a name="boost_typetraits.reference.has_trivial_constructor"></a><a class="link" href="has_trivial_constructor.html" title="has_trivial_constructor">has_trivial_constructor</a> +</h3></div></div></div> +<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">has_trivial_constructor</span> <span class="special">:</span> <span class="keyword">public</span> <em class="replaceable"><code><a class="link" href="integral_constant.html" title="integral_constant">true_type</a>-or-<a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code></em> <span class="special">{};</span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">has_trivial_default_constructor</span> <span class="special">:</span> <span class="keyword">public</span> <em class="replaceable"><code><a class="link" href="integral_constant.html" title="integral_constant">true_type</a>-or-<a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code></em> <span class="special">{};</span> +</pre> +<p> + <span class="bold"><strong>Inherits:</strong></span> If T is a (possibly cv-qualified) + type with a trivial default-constructor then inherits from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>, + otherwise inherits from <a class="link" href="integral_constant.html" title="integral_constant">false_type</a>. + </p> +<p> + These two traits are synonyms for each other. + </p> +<p> + 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. + </p> +<p> + <span class="bold"><strong>Compiler Compatibility:</strong></span> If the compiler + does not support partial-specialization of class templates, then this template + can not be used with function types. + </p> +<p> + 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 2011) compilers + more recent than Visual C++ 8, GCC-4.3, Greenhills 6.0, Intel-11.0, and Codegear + have the necessary compiler <a class="link" href="../intrinsics.html" title="Support for Compiler Intrinsics">intrinsics</a> + to ensure that this trait "just works". You may also test to see + if the necessary <a class="link" href="../intrinsics.html" title="Support for Compiler Intrinsics">intrinsics</a> + are available by checking to see if the macro <code class="computeroutput"><span class="identifier">BOOST_HAS_TRIVIAL_CONSTRUCTOR</span></code> + is defined. + </p> +<p> + <span class="bold"><strong>C++ Standard Reference:</strong></span> 12.1p6. + </p> +<p> + <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"> <span class="preprocessor">#include</span> + <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_trivial_constructor</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + </p> +<p> + <span class="bold"><strong>Examples:</strong></span> + </p> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_trivial_constructor</span><span class="special"><</span><span class="keyword">int</span><span class="special">></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_trivial_constructor</span><span class="special"><</span><span class="keyword">char</span><span class="special">*>::</span><span class="identifier">type</span></code> + is the type <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_trivial_constructor</span><span class="special"><</span><span class="keyword">int</span> <span class="special">(*)(</span><span class="keyword">long</span><span class="special">)>::</span><span class="identifier">value</span></code> + is an integral constant expression that evaluates to <span class="emphasis"><em>true</em></span>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_trivial_constructor</span><span class="special"><</span><span class="identifier">MyClass</span><span class="special">>::</span><span class="identifier">value</span></code> + is an integral constant expression that evaluates to <span class="emphasis"><em>false</em></span>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_trivial_constructor</span><span class="special"><</span><span class="identifier">T</span><span class="special">>::</span><span class="identifier">value_type</span></code> + is the type <code class="computeroutput"><span class="keyword">bool</span></code>. + </p></blockquote></div> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="has_trivial_assign.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="has_trivial_copy.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/reference/has_trivial_copy.html b/libs/type_traits/doc/html/boost_typetraits/reference/has_trivial_copy.html new file mode 100644 index 0000000000..dc1362cb7e --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/reference/has_trivial_copy.html @@ -0,0 +1,111 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>has_trivial_copy</title> +<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../reference.html" title="Alphabetical Reference"> +<link rel="prev" href="has_trivial_constructor.html" title="has_trivial_constructor"> +<link rel="next" href="has_trivial_cp_cons.html" title="has_trivial_copy_constructor"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td> +<td align="center"><a href="../../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="has_trivial_constructor.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="has_trivial_cp_cons.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h3 class="title"> +<a name="boost_typetraits.reference.has_trivial_copy"></a><a class="link" href="has_trivial_copy.html" title="has_trivial_copy">has_trivial_copy</a> +</h3></div></div></div> +<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">has_trivial_copy</span> <span class="special">:</span> <span class="keyword">public</span> <em class="replaceable"><code><a class="link" href="integral_constant.html" title="integral_constant">true_type</a>-or-<a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code></em> <span class="special">{};</span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">has_trivial_copy_constructor</span> <span class="special">:</span> <span class="keyword">public</span> <em class="replaceable"><code><a class="link" href="integral_constant.html" title="integral_constant">true_type</a>-or-<a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code></em> <span class="special">{};</span> +</pre> +<p> + <span class="bold"><strong>Inherits:</strong></span> If T is a (possibly cv-qualified) + type with a trivial copy-constructor then inherits from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>, + otherwise inherits from <a class="link" href="integral_constant.html" title="integral_constant">false_type</a>. + </p> +<p> + These two traits are synonyms for each other. + </p> +<p> + 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 <code class="computeroutput"><span class="identifier">memcpy</span></code>. + </p> +<p> + <span class="bold"><strong>Compiler Compatibility:</strong></span> If the compiler + does not support partial-specialization of class templates, then this template + can not be used with function types. + </p> +<p> + 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 2011) compilers + more recent than Visual C++ 8, GCC-4.3, Greenhills 6.0, Intel-11.0, and Codegear + have the necessary compiler <a class="link" href="../intrinsics.html" title="Support for Compiler Intrinsics">intrinsics</a> + to ensure that this trait "just works". You may also test to see + if the necessary <a class="link" href="../intrinsics.html" title="Support for Compiler Intrinsics">intrinsics</a> + are available by checking to see if the macro <code class="computeroutput"><span class="identifier">BOOST_HAS_TRIVIAL_COPY</span></code> + is defined. + </p> +<p> + <span class="bold"><strong>C++ Standard Reference:</strong></span> 12.8p6. + </p> +<p> + <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"> <span class="preprocessor">#include</span> + <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_trivial_copy</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + </p> +<p> + <span class="bold"><strong>Examples:</strong></span> + </p> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_trivial_copy</span><span class="special"><</span><span class="keyword">int</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_trivial_copy</span><span class="special"><</span><span class="keyword">char</span><span class="special">*>::</span><span class="identifier">type</span></code> is the type <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_trivial_copy</span><span class="special"><</span><span class="keyword">int</span> <span class="special">(*)(</span><span class="keyword">long</span><span class="special">)>::</span><span class="identifier">value</span></code> is an integral constant expression + that evaluates to <span class="emphasis"><em>true</em></span>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_trivial_copy</span><span class="special"><</span><span class="identifier">MyClass</span><span class="special">>::</span><span class="identifier">value</span></code> is an integral constant expression + that evaluates to <span class="emphasis"><em>false</em></span>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_trivial_copy</span><span class="special"><</span><span class="identifier">T</span><span class="special">>::</span><span class="identifier">value_type</span></code> is the type <code class="computeroutput"><span class="keyword">bool</span></code>. + </p></blockquote></div> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="has_trivial_constructor.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="has_trivial_cp_cons.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/reference/has_trivial_cp_cons.html b/libs/type_traits/doc/html/boost_typetraits/reference/has_trivial_cp_cons.html new file mode 100644 index 0000000000..3f4026a83b --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/reference/has_trivial_cp_cons.html @@ -0,0 +1,50 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>has_trivial_copy_constructor</title> +<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../reference.html" title="Alphabetical Reference"> +<link rel="prev" href="has_trivial_copy.html" title="has_trivial_copy"> +<link rel="next" href="has_trivial_def_cons.html" title="has_trivial_default_constructor"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td> +<td align="center"><a href="../../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="has_trivial_copy.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="has_trivial_def_cons.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h3 class="title"> +<a name="boost_typetraits.reference.has_trivial_cp_cons"></a><a class="link" href="has_trivial_cp_cons.html" title="has_trivial_copy_constructor">has_trivial_copy_constructor</a> +</h3></div></div></div> +<p> + See <a class="link" href="has_trivial_copy.html" title="has_trivial_copy">has_trivial_copy</a>. + </p> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="has_trivial_copy.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="has_trivial_def_cons.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/reference/has_trivial_def_cons.html b/libs/type_traits/doc/html/boost_typetraits/reference/has_trivial_def_cons.html new file mode 100644 index 0000000000..d291265554 --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/reference/has_trivial_def_cons.html @@ -0,0 +1,50 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>has_trivial_default_constructor</title> +<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../reference.html" title="Alphabetical Reference"> +<link rel="prev" href="has_trivial_cp_cons.html" title="has_trivial_copy_constructor"> +<link rel="next" href="has_trivial_destructor.html" title="has_trivial_destructor"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td> +<td align="center"><a href="../../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="has_trivial_cp_cons.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="has_trivial_destructor.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h3 class="title"> +<a name="boost_typetraits.reference.has_trivial_def_cons"></a><a class="link" href="has_trivial_def_cons.html" title="has_trivial_default_constructor">has_trivial_default_constructor</a> +</h3></div></div></div> +<p> + See <a class="link" href="has_trivial_constructor.html" title="has_trivial_constructor">has_trivial_constructor</a>. + </p> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="has_trivial_cp_cons.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="has_trivial_destructor.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/reference/has_trivial_destructor.html b/libs/type_traits/doc/html/boost_typetraits/reference/has_trivial_destructor.html new file mode 100644 index 0000000000..e48d02db6a --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/reference/has_trivial_destructor.html @@ -0,0 +1,108 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>has_trivial_destructor</title> +<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../reference.html" title="Alphabetical Reference"> +<link rel="prev" href="has_trivial_def_cons.html" title="has_trivial_default_constructor"> +<link rel="next" href="has_unary_minus.html" title="has_unary_minus"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td> +<td align="center"><a href="../../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="has_trivial_def_cons.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="has_unary_minus.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h3 class="title"> +<a name="boost_typetraits.reference.has_trivial_destructor"></a><a class="link" href="has_trivial_destructor.html" title="has_trivial_destructor">has_trivial_destructor</a> +</h3></div></div></div> +<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">has_trivial_destructor</span> <span class="special">:</span> <span class="keyword">public</span> <em class="replaceable"><code><a class="link" href="integral_constant.html" title="integral_constant">true_type</a>-or-<a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code></em> <span class="special">{};</span> +</pre> +<p> + <span class="bold"><strong>Inherits:</strong></span> If T is a (possibly cv-qualified) + type with a trivial destructor then inherits from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>, + otherwise inherits from <a class="link" href="integral_constant.html" title="integral_constant">false_type</a>. + </p> +<p> + 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. + </p> +<p> + <span class="bold"><strong>Compiler Compatibility:</strong></span> If the compiler + does not support partial-specialization of class templates, then this template + can not be used with function types. + </p> +<p> + 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 2011) compilers + more recent than Visual C++ 8, GCC-4.3, Greenhills 6.0, Intel-11.0, and Codegear + have the necessary compiler <a class="link" href="../intrinsics.html" title="Support for Compiler Intrinsics">intrinsics</a> + to ensure that this trait "just works". You may also test to see + if the necessary <a class="link" href="../intrinsics.html" title="Support for Compiler Intrinsics">intrinsics</a> + are available by checking to see if the macro <code class="computeroutput"><span class="identifier">BOOST_HAS_TRIVIAL_DESTRUCTOR</span></code> + is defined. + </p> +<p> + <span class="bold"><strong>C++ Standard Reference:</strong></span> 12.4p3. + </p> +<p> + <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"> <span class="preprocessor">#include</span> + <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_trivial_destructor</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + </p> +<p> + <span class="bold"><strong>Examples:</strong></span> + </p> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_trivial_destructor</span><span class="special"><</span><span class="keyword">int</span><span class="special">></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_trivial_destructor</span><span class="special"><</span><span class="keyword">char</span><span class="special">*>::</span><span class="identifier">type</span></code> + is the type <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_trivial_destructor</span><span class="special"><</span><span class="keyword">int</span> <span class="special">(*)(</span><span class="keyword">long</span><span class="special">)>::</span><span class="identifier">value</span></code> + is an integral constant expression that evaluates to <span class="emphasis"><em>true</em></span>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_trivial_destructor</span><span class="special"><</span><span class="identifier">MyClass</span><span class="special">>::</span><span class="identifier">value</span></code> + is an integral constant expression that evaluates to <span class="emphasis"><em>false</em></span>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_trivial_destructor</span><span class="special"><</span><span class="identifier">T</span><span class="special">>::</span><span class="identifier">value_type</span></code> + is the type <code class="computeroutput"><span class="keyword">bool</span></code>. + </p></blockquote></div> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="has_trivial_def_cons.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="has_unary_minus.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/reference/has_unary_minus.html b/libs/type_traits/doc/html/boost_typetraits/reference/has_unary_minus.html new file mode 100644 index 0000000000..0320950a0d --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/reference/has_unary_minus.html @@ -0,0 +1,195 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>has_unary_minus</title> +<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../reference.html" title="Alphabetical Reference"> +<link rel="prev" href="has_trivial_destructor.html" title="has_trivial_destructor"> +<link rel="next" href="has_unary_plus.html" title="has_unary_plus"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td> +<td align="center"><a href="../../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="has_trivial_destructor.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="has_unary_plus.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h3 class="title"> +<a name="boost_typetraits.reference.has_unary_minus"></a><a class="link" href="has_unary_minus.html" title="has_unary_minus">has_unary_minus</a> +</h3></div></div></div> +<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">Rhs</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Ret</span><span class="special">=</span><span class="identifier">dont_care</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">has_unary_minus</span> <span class="special">:</span> <span class="keyword">public</span> <em class="replaceable"><code><a class="link" href="integral_constant.html" title="integral_constant">true_type</a>-or-<a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code></em> <span class="special">{};</span> +</pre> +<p> + <span class="bold"><strong>Inherits:</strong></span> If (i) <code class="computeroutput"><span class="identifier">rhs</span></code> + of type <code class="computeroutput"><span class="identifier">Rhs</span></code> can be used in + expression <code class="computeroutput"><span class="special">-</span><span class="identifier">rhs</span></code>, + and (ii) <code class="computeroutput"><span class="identifier">Ret</span><span class="special">=</span><span class="identifier">dont_care</span></code> or the result of expression + <code class="computeroutput"><span class="special">-</span><span class="identifier">rhs</span></code> + is convertible to <code class="computeroutput"><span class="identifier">Ret</span></code> then + inherits from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>, + otherwise inherits from <a class="link" href="integral_constant.html" title="integral_constant">false_type</a>. + </p> +<p> + The default behaviour (<code class="computeroutput"><span class="identifier">Ret</span><span class="special">=</span><span class="identifier">dont_care</span></code>) + is to not check for the return value of prefix <code class="computeroutput"><span class="keyword">operator</span><span class="special">-</span></code>. If <code class="computeroutput"><span class="identifier">Ret</span></code> + is different from the default <code class="computeroutput"><span class="identifier">dont_care</span></code> + type, the return value is checked to be convertible to <code class="computeroutput"><span class="identifier">Ret</span></code>. + Convertible to <code class="computeroutput"><span class="identifier">Ret</span></code> means + that the return value of the operator can be used as argument to a function + expecting <code class="computeroutput"><span class="identifier">Ret</span></code>: +</p> +<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">Ret</span><span class="special">);</span> +<span class="identifier">Rhs</span> <span class="identifier">rhs</span><span class="special">;</span> +<span class="identifier">f</span><span class="special">(-</span><span class="identifier">rhs</span><span class="special">);</span> <span class="comment">// is valid if has_unary_minus<Rhs, Ret>::value==true</span> +</pre> +<p> + If <code class="computeroutput"><span class="identifier">Ret</span><span class="special">=</span><span class="keyword">void</span></code>, the return type is checked to be exactly + <code class="computeroutput"><span class="keyword">void</span></code>. + </p> +<p> + <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"><span class="preprocessor">#include</span> + <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_unary_minus</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_operator</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + </p> +<p> + <span class="bold"><strong>Examples:</strong></span> + </p> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_unary_minus</span><span class="special"><</span><span class="identifier">Rhs</span><span class="special">,</span> <span class="identifier">Ret</span><span class="special">>::</span><span class="identifier">value_type</span></code> is the type <code class="computeroutput"><span class="keyword">bool</span></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_unary_minus</span><span class="special"><</span><span class="identifier">Rhs</span><span class="special">,</span> <span class="identifier">Ret</span><span class="special">>::</span><span class="identifier">value</span></code> is a <code class="computeroutput"><span class="keyword">bool</span></code> + integral constant expression. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_unary_minus</span><span class="special"><</span><span class="keyword">int</span><span class="special">>::</span><span class="identifier">value</span></code> is a <code class="computeroutput"><span class="keyword">bool</span></code> + integral constant expression that evaluates to <code class="computeroutput"><span class="keyword">true</span></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_unary_minus</span><span class="special"><</span><span class="keyword">long</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_unary_minus</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_unary_minus</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">long</span><span class="special">></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_unary_minus</span><span class="special"><</span><span class="keyword">double</span><span class="special">,</span> <span class="keyword">double</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_unary_minus</span><span class="special"><</span><span class="keyword">double</span><span class="special">,</span> <span class="keyword">int</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_unary_minus</span><span class="special"><</span><span class="keyword">const</span> <span class="keyword">int</span><span class="special">></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_unary_minus</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>. + </p></blockquote></div> +<p> + <span class="bold"><strong>See also:</strong></span> <a class="link" href="../category/value_traits/operators.html" title="Operator Type Traits">Operator + Type Traits</a> + </p> +<p> + <span class="bold"><strong>Limitation:</strong></span> + </p> +<div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"> + Requires a compiler with working SFINAE. + </li></ul></div> +<p> + <span class="bold"><strong>Known issues:</strong></span> + </p> +<div class="itemizedlist"><ul class="itemizedlist" type="disc"> +<li class="listitem"> + This trait cannot detect whether prefix <code class="computeroutput"><span class="keyword">operator</span><span class="special">-</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">-</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">Rhs</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_unary_minus</span><span class="special"><</span><span class="identifier">Rhs</span><span class="special">></span></code> + will produce a compiler error. For this reason <code class="computeroutput"><span class="identifier">has_unary_minus</span></code> + cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">-</span></code> + or not. +<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">-();</span> <span class="special">};</span> +<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_unary_minus</span><span class="special"><</span><span class="identifier">A</span><span class="special">>::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator-() is private</span> +</pre> + </li> +<li class="listitem"> + There is an issue if the operator exists only for type <code class="computeroutput"><span class="identifier">A</span></code> and <code class="computeroutput"><span class="identifier">B</span></code> + is convertible to <code class="computeroutput"><span class="identifier">A</span></code>. + In this case, the compiler will report an ambiguous overload. +<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span> +<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">-(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&);</span> +<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span> +<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_unary_minus</span><span class="special"><</span><span class="identifier">A</span><span class="special">>::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine</span> +<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_unary_minus</span><span class="special"><</span><span class="identifier">B</span><span class="special">>::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambiguous overload</span> +</pre> + </li> +<li class="listitem"> + There is an issue when applying this trait to template classes. If <code class="computeroutput"><span class="keyword">operator</span><span class="special">-</span></code> + is defined but does not bind for a given template type, it is still detected + by the trait which returns <code class="computeroutput"><span class="keyword">true</span></code> + instead of <code class="computeroutput"><span class="keyword">false</span></code>. Example: + +<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_unary_minus</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span> +<span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">iostream</span><span class="special">></span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">contains</span> <span class="special">{</span> <span class="identifier">T</span> <span class="identifier">data</span><span class="special">;</span> <span class="special">};</span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">-(</span><span class="keyword">const</span> <span class="identifier">contains</span><span class="special"><</span><span class="identifier">T</span><span class="special">></span> <span class="special">&</span><span class="identifier">rhs</span><span class="special">)</span> <span class="special">{</span> + <span class="keyword">return</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">rhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">);</span> +<span class="special">}</span> + +<span class="keyword">class</span> <span class="identifier">bad</span> <span class="special">{</span> <span class="special">};</span> +<span class="keyword">class</span> <span class="identifier">good</span> <span class="special">{</span> <span class="special">};</span> +<span class="keyword">bool</span> <span class="identifier">f</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">good</span><span class="special">&)</span> <span class="special">{</span> <span class="special">}</span> + +<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span> <span class="special">{</span> + <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special"><<</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">boolalpha</span><span class="special">;</span> + <span class="comment">// works fine for contains<good></span> + <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special"><<</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_unary_minus</span><span class="special"><</span> <span class="identifier">contains</span><span class="special"><</span> <span class="identifier">good</span> <span class="special">></span> <span class="special">>::</span><span class="identifier">value</span><span class="special"><<</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true</span> + <span class="identifier">contains</span><span class="special"><</span><span class="identifier">good</span><span class="special">></span> <span class="identifier">g</span><span class="special">;</span> + <span class="special">-</span><span class="identifier">g</span><span class="special">;</span> <span class="comment">// ok</span> + <span class="comment">// does not work for contains<bad></span> + <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special"><<</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_unary_minus</span><span class="special"><</span> <span class="identifier">contains</span><span class="special"><</span> <span class="identifier">bad</span> <span class="special">></span> <span class="special">>::</span><span class="identifier">value</span><span class="special"><<</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true, should be false</span> + <span class="identifier">contains</span><span class="special"><</span><span class="identifier">bad</span><span class="special">></span> <span class="identifier">b</span><span class="special">;</span> + <span class="special">-</span><span class="identifier">b</span><span class="special">;</span> <span class="comment">// compile time error</span> + <span class="keyword">return</span> <span class="number">0</span><span class="special">;</span> +<span class="special">}</span> +</pre> + </li> +<li class="listitem"> + <code class="computeroutput"><span class="keyword">volatile</span></code> qualifier is not + properly handled and would lead to undefined behavior + </li> +</ul></div> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="has_trivial_destructor.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="has_unary_plus.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/reference/has_unary_plus.html b/libs/type_traits/doc/html/boost_typetraits/reference/has_unary_plus.html new file mode 100644 index 0000000000..9b76f44665 --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/reference/has_unary_plus.html @@ -0,0 +1,195 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>has_unary_plus</title> +<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../reference.html" title="Alphabetical Reference"> +<link rel="prev" href="has_unary_minus.html" title="has_unary_minus"> +<link rel="next" href="has_virtual_destructor.html" title="has_virtual_destructor"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td> +<td align="center"><a href="../../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="has_unary_minus.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="has_virtual_destructor.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h3 class="title"> +<a name="boost_typetraits.reference.has_unary_plus"></a><a class="link" href="has_unary_plus.html" title="has_unary_plus">has_unary_plus</a> +</h3></div></div></div> +<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">Rhs</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Ret</span><span class="special">=</span><span class="identifier">dont_care</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">has_unary_plus</span> <span class="special">:</span> <span class="keyword">public</span> <em class="replaceable"><code><a class="link" href="integral_constant.html" title="integral_constant">true_type</a>-or-<a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code></em> <span class="special">{};</span> +</pre> +<p> + <span class="bold"><strong>Inherits:</strong></span> If (i) <code class="computeroutput"><span class="identifier">rhs</span></code> + of type <code class="computeroutput"><span class="identifier">Rhs</span></code> can be used in + expression <code class="computeroutput"><span class="special">+</span><span class="identifier">rhs</span></code>, + and (ii) <code class="computeroutput"><span class="identifier">Ret</span><span class="special">=</span><span class="identifier">dont_care</span></code> or the result of expression + <code class="computeroutput"><span class="special">+</span><span class="identifier">rhs</span></code> + is convertible to <code class="computeroutput"><span class="identifier">Ret</span></code> then + inherits from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>, + otherwise inherits from <a class="link" href="integral_constant.html" title="integral_constant">false_type</a>. + </p> +<p> + The default behaviour (<code class="computeroutput"><span class="identifier">Ret</span><span class="special">=</span><span class="identifier">dont_care</span></code>) + is to not check for the return value of prefix <code class="computeroutput"><span class="keyword">operator</span><span class="special">+</span></code>. If <code class="computeroutput"><span class="identifier">Ret</span></code> + is different from the default <code class="computeroutput"><span class="identifier">dont_care</span></code> + type, the return value is checked to be convertible to <code class="computeroutput"><span class="identifier">Ret</span></code>. + Convertible to <code class="computeroutput"><span class="identifier">Ret</span></code> means + that the return value of the operator can be used as argument to a function + expecting <code class="computeroutput"><span class="identifier">Ret</span></code>: +</p> +<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">Ret</span><span class="special">);</span> +<span class="identifier">Rhs</span> <span class="identifier">rhs</span><span class="special">;</span> +<span class="identifier">f</span><span class="special">(+</span><span class="identifier">rhs</span><span class="special">);</span> <span class="comment">// is valid if has_unary_plus<Rhs, Ret>::value==true</span> +</pre> +<p> + If <code class="computeroutput"><span class="identifier">Ret</span><span class="special">=</span><span class="keyword">void</span></code>, the return type is checked to be exactly + <code class="computeroutput"><span class="keyword">void</span></code>. + </p> +<p> + <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"><span class="preprocessor">#include</span> + <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_unary_plus</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_operator</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + </p> +<p> + <span class="bold"><strong>Examples:</strong></span> + </p> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_unary_plus</span><span class="special"><</span><span class="identifier">Rhs</span><span class="special">,</span> <span class="identifier">Ret</span><span class="special">>::</span><span class="identifier">value_type</span></code> is the type <code class="computeroutput"><span class="keyword">bool</span></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_unary_plus</span><span class="special"><</span><span class="identifier">Rhs</span><span class="special">,</span> <span class="identifier">Ret</span><span class="special">>::</span><span class="identifier">value</span></code> is a <code class="computeroutput"><span class="keyword">bool</span></code> + integral constant expression. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_unary_plus</span><span class="special"><</span><span class="keyword">int</span><span class="special">>::</span><span class="identifier">value</span></code> is a <code class="computeroutput"><span class="keyword">bool</span></code> + integral constant expression that evaluates to <code class="computeroutput"><span class="keyword">true</span></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_unary_plus</span><span class="special"><</span><span class="keyword">long</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_unary_plus</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_unary_plus</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">long</span><span class="special">></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_unary_plus</span><span class="special"><</span><span class="keyword">double</span><span class="special">,</span> <span class="keyword">double</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_unary_plus</span><span class="special"><</span><span class="keyword">double</span><span class="special">,</span> <span class="keyword">int</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_unary_plus</span><span class="special"><</span><span class="keyword">const</span> <span class="keyword">int</span><span class="special">></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">has_unary_plus</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>. + </p></blockquote></div> +<p> + <span class="bold"><strong>See also:</strong></span> <a class="link" href="../category/value_traits/operators.html" title="Operator Type Traits">Operator + Type Traits</a> + </p> +<p> + <span class="bold"><strong>Limitation:</strong></span> + </p> +<div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"> + Requires a compiler with working SFINAE. + </li></ul></div> +<p> + <span class="bold"><strong>Known issues:</strong></span> + </p> +<div class="itemizedlist"><ul class="itemizedlist" type="disc"> +<li class="listitem"> + This trait cannot detect whether prefix <code class="computeroutput"><span class="keyword">operator</span><span class="special">+</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">+</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">Rhs</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_unary_plus</span><span class="special"><</span><span class="identifier">Rhs</span><span class="special">></span></code> + will produce a compiler error. For this reason <code class="computeroutput"><span class="identifier">has_unary_plus</span></code> + cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">+</span></code> + or not. +<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">+();</span> <span class="special">};</span> +<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_unary_plus</span><span class="special"><</span><span class="identifier">A</span><span class="special">>::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator+() is private</span> +</pre> + </li> +<li class="listitem"> + There is an issue if the operator exists only for type <code class="computeroutput"><span class="identifier">A</span></code> and <code class="computeroutput"><span class="identifier">B</span></code> + is convertible to <code class="computeroutput"><span class="identifier">A</span></code>. + In this case, the compiler will report an ambiguous overload. +<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span> +<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">+(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&);</span> +<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span> +<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_unary_plus</span><span class="special"><</span><span class="identifier">A</span><span class="special">>::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine</span> +<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_unary_plus</span><span class="special"><</span><span class="identifier">B</span><span class="special">>::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambiguous overload</span> +</pre> + </li> +<li class="listitem"> + There is an issue when applying this trait to template classes. If <code class="computeroutput"><span class="keyword">operator</span><span class="special">+</span></code> + is defined but does not bind for a given template type, it is still detected + by the trait which returns <code class="computeroutput"><span class="keyword">true</span></code> + instead of <code class="computeroutput"><span class="keyword">false</span></code>. Example: + +<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_unary_plus</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span> +<span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">iostream</span><span class="special">></span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">contains</span> <span class="special">{</span> <span class="identifier">T</span> <span class="identifier">data</span><span class="special">;</span> <span class="special">};</span> + +<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">+(</span><span class="keyword">const</span> <span class="identifier">contains</span><span class="special"><</span><span class="identifier">T</span><span class="special">></span> <span class="special">&</span><span class="identifier">rhs</span><span class="special">)</span> <span class="special">{</span> + <span class="keyword">return</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">rhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">);</span> +<span class="special">}</span> + +<span class="keyword">class</span> <span class="identifier">bad</span> <span class="special">{</span> <span class="special">};</span> +<span class="keyword">class</span> <span class="identifier">good</span> <span class="special">{</span> <span class="special">};</span> +<span class="keyword">bool</span> <span class="identifier">f</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">good</span><span class="special">&)</span> <span class="special">{</span> <span class="special">}</span> + +<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span> <span class="special">{</span> + <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special"><<</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">boolalpha</span><span class="special">;</span> + <span class="comment">// works fine for contains<good></span> + <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special"><<</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_unary_plus</span><span class="special"><</span> <span class="identifier">contains</span><span class="special"><</span> <span class="identifier">good</span> <span class="special">></span> <span class="special">>::</span><span class="identifier">value</span><span class="special"><<</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true</span> + <span class="identifier">contains</span><span class="special"><</span><span class="identifier">good</span><span class="special">></span> <span class="identifier">g</span><span class="special">;</span> + <span class="special">+</span><span class="identifier">g</span><span class="special">;</span> <span class="comment">// ok</span> + <span class="comment">// does not work for contains<bad></span> + <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special"><<</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_unary_plus</span><span class="special"><</span> <span class="identifier">contains</span><span class="special"><</span> <span class="identifier">bad</span> <span class="special">></span> <span class="special">>::</span><span class="identifier">value</span><span class="special"><<</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true, should be false</span> + <span class="identifier">contains</span><span class="special"><</span><span class="identifier">bad</span><span class="special">></span> <span class="identifier">b</span><span class="special">;</span> + <span class="special">+</span><span class="identifier">b</span><span class="special">;</span> <span class="comment">// compile time error</span> + <span class="keyword">return</span> <span class="number">0</span><span class="special">;</span> +<span class="special">}</span> +</pre> + </li> +<li class="listitem"> + <code class="computeroutput"><span class="keyword">volatile</span></code> qualifier is not + properly handled and would lead to undefined behavior + </li> +</ul></div> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="has_unary_minus.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="has_virtual_destructor.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/reference/has_virtual_destructor.html b/libs/type_traits/doc/html/boost_typetraits/reference/has_virtual_destructor.html new file mode 100644 index 0000000000..6a38c6119f --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/reference/has_virtual_destructor.html @@ -0,0 +1,78 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>has_virtual_destructor</title> +<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../reference.html" title="Alphabetical Reference"> +<link rel="prev" href="has_unary_plus.html" title="has_unary_plus"> +<link rel="next" href="integral_constant.html" title="integral_constant"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td> +<td align="center"><a href="../../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="has_unary_plus.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="integral_constant.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h3 class="title"> +<a name="boost_typetraits.reference.has_virtual_destructor"></a><a class="link" href="has_virtual_destructor.html" title="has_virtual_destructor">has_virtual_destructor</a> +</h3></div></div></div> +<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">has_virtual_destructor</span> <span class="special">:</span> <span class="keyword">public</span> <em class="replaceable"><code><a class="link" href="integral_constant.html" title="integral_constant">true_type</a>-or-<a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code></em> <span class="special">{};</span> +</pre> +<p> + <span class="bold"><strong>Inherits:</strong></span> If T is a (possibly cv-qualified) + type with a virtual destructor then inherits from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>, + otherwise inherits from <a class="link" href="integral_constant.html" title="integral_constant">false_type</a>. + </p> +<p> + <span class="bold"><strong>Compiler Compatibility:</strong></span> 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 <a class="link" href="integral_constant.html" title="integral_constant">false_type</a>, + and has to be explicitly specialized for types with virtual destructors unless + the compiler used has compiler <a class="link" href="../intrinsics.html" title="Support for Compiler Intrinsics">intrinsics</a> + that enable the trait to do the right thing: Currently (May 2011) compilers + more recent than Visual C++ 8, GCC-4.3, Greenhills 6.0, Intel-11.0, and Codegear + have the necessary compiler <a class="link" href="../intrinsics.html" title="Support for Compiler Intrinsics">intrinsics</a> + to ensure that this trait "just works". You may also test to see + if the necessary <a class="link" href="../intrinsics.html" title="Support for Compiler Intrinsics">intrinsics</a> + are available by checking to see if the macro <code class="computeroutput"><span class="identifier">BOOST_HAS_VIRTUAL_DESTRUCTOR</span></code> + is defined. + </p> +<p> + <span class="bold"><strong>C++ Standard Reference:</strong></span> 12.4. + </p> +<p> + <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"> <span class="preprocessor">#include</span> + <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_virtual_destructor</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + </p> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="has_unary_plus.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="integral_constant.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/reference/integral_constant.html b/libs/type_traits/doc/html/boost_typetraits/reference/integral_constant.html new file mode 100644 index 0000000000..54c7a75889 --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/reference/integral_constant.html @@ -0,0 +1,65 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>integral_constant</title> +<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../reference.html" title="Alphabetical Reference"> +<link rel="prev" href="has_virtual_destructor.html" title="has_virtual_destructor"> +<link rel="next" href="integral_promotion.html" title="integral_promotion"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td> +<td align="center"><a href="../../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="has_virtual_destructor.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="integral_promotion.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h3 class="title"> +<a name="boost_typetraits.reference.integral_constant"></a><a class="link" href="integral_constant.html" title="integral_constant">integral_constant</a> +</h3></div></div></div> +<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">T</span> <span class="identifier">val</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">integral_constant</span> +<span class="special">{</span> + <span class="keyword">typedef</span> <span class="identifier">integral_constant</span><span class="special"><</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">val</span><span class="special">></span> <span class="identifier">type</span><span class="special">;</span> + <span class="keyword">typedef</span> <span class="identifier">T</span> <span class="identifier">value_type</span><span class="special">;</span> + <span class="keyword">static</span> <span class="keyword">const</span> <span class="identifier">T</span> <span class="identifier">value</span> <span class="special">=</span> <span class="identifier">val</span><span class="special">;</span> +<span class="special">};</span> + +<span class="keyword">typedef</span> <span class="identifier">integral_constant</span><span class="special"><</span><span class="keyword">bool</span><span class="special">,</span> <span class="keyword">true</span><span class="special">></span> <span class="identifier">true_type</span><span class="special">;</span> +<span class="keyword">typedef</span> <span class="identifier">integral_constant</span><span class="special"><</span><span class="keyword">bool</span><span class="special">,</span> <span class="keyword">false</span><span class="special">></span> <span class="identifier">false_type</span><span class="special">;</span> +</pre> +<p> + Class template <code class="computeroutput"><span class="identifier">integral_constant</span></code> + is the common base class for all the value-based type traits. The two typedef's + <code class="computeroutput"><span class="identifier">true_type</span></code> and <code class="computeroutput"><span class="identifier">false_type</span></code> are provided for convenience: + most of the value traits are Boolean properties and so will inherit from + one of these. + </p> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="has_virtual_destructor.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="integral_promotion.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/reference/integral_promotion.html b/libs/type_traits/doc/html/boost_typetraits/reference/integral_promotion.html new file mode 100644 index 0000000000..a86d4716cd --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/reference/integral_promotion.html @@ -0,0 +1,131 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>integral_promotion</title> +<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../reference.html" title="Alphabetical Reference"> +<link rel="prev" href="integral_constant.html" title="integral_constant"> +<link rel="next" href="is_abstract.html" title="is_abstract"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td> +<td align="center"><a href="../../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="integral_constant.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="is_abstract.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h3 class="title"> +<a name="boost_typetraits.reference.integral_promotion"></a><a class="link" href="integral_promotion.html" title="integral_promotion">integral_promotion</a> +</h3></div></div></div> +<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">integral_promotion</span> +<span class="special">{</span> + <span class="keyword">typedef</span> <em class="replaceable"><code>see-below</code></em> <span class="identifier">type</span><span class="special">;</span> +<span class="special">};</span> +</pre> +<p> + <span class="bold"><strong>type:</strong></span> If integral promotion can be applied + to an rvalue of type <code class="computeroutput"><span class="identifier">T</span></code>, then + applies integral promotion to <code class="computeroutput"><span class="identifier">T</span></code> + and keeps cv-qualifiers of <code class="computeroutput"><span class="identifier">T</span></code>, + otherwise leaves <code class="computeroutput"><span class="identifier">T</span></code> unchanged. + </p> +<p> + <span class="bold"><strong>C++ Standard Reference:</strong></span> 4.5 except 4.5/3 + (integral bit-field). + </p> +<p> + <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"> <span class="preprocessor">#include</span> + <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">integral_promotion</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + </p> +<div class="table"> +<a name="boost_typetraits.reference.integral_promotion.examples"></a><p class="title"><b>Table 1.21. Examples</b></p> +<div class="table-contents"><table class="table" summary="Examples"> +<colgroup> +<col> +<col> +</colgroup> +<thead><tr> +<th> + <p> + Expression + </p> + </th> +<th> + <p> + Result Type + </p> + </th> +</tr></thead> +<tbody> +<tr> +<td> + <p> + <code class="computeroutput"><span class="identifier">integral_promotion</span><span class="special"><</span><span class="keyword">short</span> + <span class="keyword">const</span><span class="special">>::</span><span class="identifier">type</span></code> + </p> + </td> +<td> + <p> + <code class="computeroutput"><span class="keyword">int</span> <span class="keyword">const</span></code> + </p> + </td> +</tr> +<tr> +<td> + <p> + <code class="computeroutput"><span class="identifier">integral_promotion</span><span class="special"><</span><span class="keyword">short</span><span class="special">&>::</span><span class="identifier">type</span></code> + </p> + </td> +<td> + <p> + <code class="computeroutput"><span class="keyword">short</span><span class="special">&</span></code> + </p> + </td> +</tr> +<tr> +<td> + <p> + <code class="computeroutput"><span class="identifier">integral_promotion</span><span class="special"><</span><span class="keyword">enum</span> + <span class="identifier">std</span><span class="special">::</span><span class="identifier">float_round_style</span><span class="special">>::</span><span class="identifier">type</span></code> + </p> + </td> +<td> + <p> + <code class="computeroutput"><span class="keyword">int</span></code> + </p> + </td> +</tr> +</tbody> +</table></div> +</div> +<br class="table-break"> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="integral_constant.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="is_abstract.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/reference/is_abstract.html b/libs/type_traits/doc/html/boost_typetraits/reference/is_abstract.html new file mode 100644 index 0000000000..6d02c90c33 --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/reference/is_abstract.html @@ -0,0 +1,93 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>is_abstract</title> +<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../reference.html" title="Alphabetical Reference"> +<link rel="prev" href="integral_promotion.html" title="integral_promotion"> +<link rel="next" href="is_arithmetic.html" title="is_arithmetic"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td> +<td align="center"><a href="../../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="integral_promotion.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="is_arithmetic.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h3 class="title"> +<a name="boost_typetraits.reference.is_abstract"></a><a class="link" href="is_abstract.html" title="is_abstract">is_abstract</a> +</h3></div></div></div> +<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">is_abstract</span> <span class="special">:</span> <span class="keyword">public</span> <em class="replaceable"><code><a class="link" href="integral_constant.html" title="integral_constant">true_type</a>-or-<a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code></em> <span class="special">{};</span> +</pre> +<p> + <span class="bold"><strong>Inherits:</strong></span> If T is a (possibly cv-qualified) + abstract type then inherits from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>, + otherwise inherits from <a class="link" href="integral_constant.html" title="integral_constant">false_type</a>. + </p> +<p> + <span class="bold"><strong>C++ Standard Reference:</strong></span> 10.3. + </p> +<p> + <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"> <span class="preprocessor">#include</span> + <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">is_abstract</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + </p> +<p> + <span class="bold"><strong>Compiler Compatibility:</strong></span> 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 <a class="link" href="is_polymorphic.html" title="is_polymorphic">is_polymorphic</a>; + 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. + </p> +<p> + <span class="bold"><strong>Examples:</strong></span> + </p> +<div class="blockquote"><blockquote class="blockquote"><p> + Given: <code class="computeroutput"><span class="keyword">class</span> <span class="identifier">abc</span><span class="special">{</span> <span class="keyword">virtual</span> <span class="special">~</span><span class="identifier">abc</span><span class="special">()</span> <span class="special">=</span> <span class="number">0</span><span class="special">;</span> <span class="special">};</span></code> + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_abstract</span><span class="special"><</span><span class="identifier">abc</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_abstract</span><span class="special"><</span><span class="identifier">abc</span><span class="special">>::</span><span class="identifier">type</span></code> is the type <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_abstract</span><span class="special"><</span><span class="identifier">abc</span> <span class="keyword">const</span><span class="special">>::</span><span class="identifier">value</span></code> + is an integral constant expression that evaluates to <span class="emphasis"><em>true</em></span>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_abstract</span><span class="special"><</span><span class="identifier">T</span><span class="special">>::</span><span class="identifier">value_type</span></code> is the type <code class="computeroutput"><span class="keyword">bool</span></code>. + </p></blockquote></div> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="integral_promotion.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="is_arithmetic.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/reference/is_arithmetic.html b/libs/type_traits/doc/html/boost_typetraits/reference/is_arithmetic.html new file mode 100644 index 0000000000..1abbaf37f2 --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/reference/is_arithmetic.html @@ -0,0 +1,82 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>is_arithmetic</title> +<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../reference.html" title="Alphabetical Reference"> +<link rel="prev" href="is_abstract.html" title="is_abstract"> +<link rel="next" href="is_array.html" title="is_array"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td> +<td align="center"><a href="../../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="is_abstract.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="is_array.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h3 class="title"> +<a name="boost_typetraits.reference.is_arithmetic"></a><a class="link" href="is_arithmetic.html" title="is_arithmetic">is_arithmetic</a> +</h3></div></div></div> +<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">is_arithmetic</span> <span class="special">:</span> <span class="keyword">public</span> <em class="replaceable"><code><a class="link" href="integral_constant.html" title="integral_constant">true_type</a>-or-<a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code></em> <span class="special">{};</span> +</pre> +<p> + <span class="bold"><strong>Inherits:</strong></span> If T is a (possibly cv-qualified) + arithmetic type then inherits from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>, + otherwise inherits from <a class="link" href="integral_constant.html" title="integral_constant">false_type</a>. + Arithmetic types include integral and floating point types (see also <a class="link" href="is_integral.html" title="is_integral">is_integral</a> and + <a class="link" href="is_floating_point.html" title="is_floating_point">is_floating_point</a>). + </p> +<p> + <span class="bold"><strong>C++ Standard Reference:</strong></span> 3.9.1p8. + </p> +<p> + <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"> <span class="preprocessor">#include</span> + <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">is_arithmetic</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + </p> +<p> + <span class="bold"><strong>Examples:</strong></span> + </p> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_arithmetic</span><span class="special"><</span><span class="keyword">int</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_arithmetic</span><span class="special"><</span><span class="keyword">char</span><span class="special">>::</span><span class="identifier">type</span></code> is the type <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_arithmetic</span><span class="special"><</span><span class="keyword">double</span><span class="special">>::</span><span class="identifier">value</span></code> is an integral constant expression + that evaluates to <span class="emphasis"><em>true</em></span>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_arithmetic</span><span class="special"><</span><span class="identifier">T</span><span class="special">>::</span><span class="identifier">value_type</span></code> is the type <code class="computeroutput"><span class="keyword">bool</span></code>. + </p></blockquote></div> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="is_abstract.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="is_array.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/reference/is_array.html b/libs/type_traits/doc/html/boost_typetraits/reference/is_array.html new file mode 100644 index 0000000000..8db32218ca --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/reference/is_array.html @@ -0,0 +1,84 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>is_array</title> +<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../reference.html" title="Alphabetical Reference"> +<link rel="prev" href="is_arithmetic.html" title="is_arithmetic"> +<link rel="next" href="is_base_of.html" title="is_base_of"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td> +<td align="center"><a href="../../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="is_arithmetic.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="is_base_of.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h3 class="title"> +<a name="boost_typetraits.reference.is_array"></a><a class="link" href="is_array.html" title="is_array">is_array</a> +</h3></div></div></div> +<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">is_array</span> <span class="special">:</span> <span class="keyword">public</span> <em class="replaceable"><code><a class="link" href="integral_constant.html" title="integral_constant">true_type</a>-or-<a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code></em> <span class="special">{};</span> +</pre> +<p> + <span class="bold"><strong>Inherits:</strong></span> If T is a (possibly cv-qualified) + array type then inherits from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>, + otherwise inherits from <a class="link" href="integral_constant.html" title="integral_constant">false_type</a>. + </p> +<p> + <span class="bold"><strong>C++ Standard Reference:</strong></span> 3.9.2 and 8.3.4. + </p> +<p> + <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"> <span class="preprocessor">#include</span> + <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">is_array</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + </p> +<p> + <span class="bold"><strong>Compiler Compatibility:</strong></span> If the compiler + does not support partial-specialization of class templates, then this template + can give the wrong result with function types. + </p> +<p> + <span class="bold"><strong>Examples:</strong></span> + </p> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_array</span><span class="special"><</span><span class="keyword">int</span><span class="special">[</span><span class="number">2</span><span class="special">]></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_array</span><span class="special"><</span><span class="keyword">char</span><span class="special">[</span><span class="number">2</span><span class="special">][</span><span class="number">3</span><span class="special">]>::</span><span class="identifier">type</span></code> is the type <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_array</span><span class="special"><</span><span class="keyword">double</span><span class="special">[]>::</span><span class="identifier">value</span></code> is an integral constant expression + that evaluates to <span class="emphasis"><em>true</em></span>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_array</span><span class="special"><</span><span class="identifier">T</span><span class="special">>::</span><span class="identifier">value_type</span></code> is the type <code class="computeroutput"><span class="keyword">bool</span></code>. + </p></blockquote></div> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="is_arithmetic.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="is_base_of.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/reference/is_base_of.html b/libs/type_traits/doc/html/boost_typetraits/reference/is_base_of.html new file mode 100644 index 0000000000..918120c8b5 --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/reference/is_base_of.html @@ -0,0 +1,111 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>is_base_of</title> +<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../reference.html" title="Alphabetical Reference"> +<link rel="prev" href="is_array.html" title="is_array"> +<link rel="next" href="is_class.html" title="is_class"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td> +<td align="center"><a href="../../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="is_array.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="is_class.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h3 class="title"> +<a name="boost_typetraits.reference.is_base_of"></a><a class="link" href="is_base_of.html" title="is_base_of">is_base_of</a> +</h3></div></div></div> +<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">Base</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Derived</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">is_base_of</span> <span class="special">:</span> <span class="keyword">public</span> <em class="replaceable"><code><a class="link" href="integral_constant.html" title="integral_constant">true_type</a>-or-<a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code></em> <span class="special">{};</span> +</pre> +<p> + <span class="bold"><strong>Inherits:</strong></span> If Base is base class of type + Derived or if both types are the same class type then inherits from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>, + otherwise inherits from <a class="link" href="integral_constant.html" title="integral_constant">false_type</a>. + </p> +<p> + This template will detect non-public base classes, and ambiguous base classes. + </p> +<p> + Note that <code class="computeroutput"><span class="identifier">is_base_of</span><span class="special"><</span><span class="identifier">X</span><span class="special">,</span><span class="identifier">X</span><span class="special">></span></code> will inherit from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a> + if X is a class type. This is a change in behaviour from Boost-1.39.0 in + order to track the emerging C++0x standard. + </p> +<p> + Types <code class="computeroutput"><span class="identifier">Base</span></code> and <code class="computeroutput"><span class="identifier">Derived</span></code> must not be incomplete types. + </p> +<p> + <span class="bold"><strong>C++ Standard Reference:</strong></span> 10. + </p> +<p> + <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"> <span class="preprocessor">#include</span> + <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">is_base_of</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + </p> +<p> + <span class="bold"><strong>Compiler Compatibility:</strong></span> 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 <code class="computeroutput"><span class="identifier">Base</span></code> + is a private base class of <code class="computeroutput"><span class="identifier">Derived</span></code>, + or if <code class="computeroutput"><span class="identifier">Base</span></code> is an ambiguous + base of <code class="computeroutput"><span class="identifier">Derived</span></code>. These compilers + include Borland C++, older versions of Sun Forte C++, Digital Mars C++, and + older versions of EDG based compilers. + </p> +<p> + <span class="bold"><strong>Examples:</strong></span> + </p> +<div class="blockquote"><blockquote class="blockquote"><p> + Given: <code class="computeroutput"> <span class="keyword">class</span> <span class="identifier">Base</span><span class="special">{};</span> <span class="keyword">class</span> <span class="identifier">Derived</span> <span class="special">:</span> <span class="keyword">public</span> <span class="identifier">Base</span><span class="special">{};</span></code> + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_base_of</span><span class="special"><</span><span class="identifier">Base</span><span class="special">,</span> <span class="identifier">Derived</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_base_of</span><span class="special"><</span><span class="identifier">Base</span><span class="special">,</span> <span class="identifier">Derived</span><span class="special">>::</span><span class="identifier">type</span></code> is the type <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_base_of</span><span class="special"><</span><span class="identifier">Base</span><span class="special">,</span> <span class="identifier">Derived</span><span class="special">>::</span><span class="identifier">value</span></code> is an integral constant expression + that evaluates to <span class="emphasis"><em>true</em></span>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_base_of</span><span class="special"><</span><span class="identifier">Base</span><span class="special">,</span> <span class="identifier">Base</span><span class="special">>::</span><span class="identifier">value</span></code> is an integral constant expression + that evaluates to <span class="emphasis"><em>true</em></span>: a class is regarded as it's + own base. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_base_of</span><span class="special"><</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">T</span><span class="special">>::</span><span class="identifier">value_type</span></code> + is the type <code class="computeroutput"><span class="keyword">bool</span></code>. + </p></blockquote></div> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="is_array.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="is_class.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/reference/is_class.html b/libs/type_traits/doc/html/boost_typetraits/reference/is_class.html new file mode 100644 index 0000000000..de1a635ef6 --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/reference/is_class.html @@ -0,0 +1,104 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>is_class</title> +<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../reference.html" title="Alphabetical Reference"> +<link rel="prev" href="is_base_of.html" title="is_base_of"> +<link rel="next" href="is_complex.html" title="is_complex"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td> +<td align="center"><a href="../../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="is_base_of.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="is_complex.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h3 class="title"> +<a name="boost_typetraits.reference.is_class"></a><a class="link" href="is_class.html" title="is_class">is_class</a> +</h3></div></div></div> +<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">is_class</span> <span class="special">:</span> <span class="keyword">public</span> <em class="replaceable"><code><a class="link" href="integral_constant.html" title="integral_constant">true_type</a>-or-<a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code></em> <span class="special">{};</span> +</pre> +<p> + <span class="bold"><strong>Inherits:</strong></span> If T is a (possibly cv-qualified) + class type (and not a union type) then inherits from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>, + otherwise inherits from <a class="link" href="integral_constant.html" title="integral_constant">false_type</a>. + </p> +<p> + <span class="bold"><strong>C++ Standard Reference:</strong></span> 3.9.2 and 9.2. + </p> +<p> + <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"> <span class="preprocessor">#include</span> + <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">is_class</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + </p> +<p> + <span class="bold"><strong>Compiler Compatibility:</strong></span> 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 <a class="link" href="integral_constant.html" title="integral_constant">true_type</a> for + union types. See also <a class="link" href="is_union.html" title="is_union">is_union</a>. + Currently (May 2011) compilers more recent than Visual C++ 8, GCC-4.3, Greenhills + 6.0, Intel-11.0, and Codegear have the necessary compiler <a class="link" href="../intrinsics.html" title="Support for Compiler Intrinsics">intrinsics</a> + to ensure that this trait "just works". You may also test to see + if the necessary <a class="link" href="../intrinsics.html" title="Support for Compiler Intrinsics">intrinsics</a> + are available by checking to see if the macro <code class="computeroutput"><span class="identifier">BOOST_IS_CLASS</span></code> + is defined. + </p> +<p> + <span class="bold"><strong>Examples:</strong></span> + </p> +<div class="blockquote"><blockquote class="blockquote"><p> + Given: <code class="computeroutput"><span class="keyword">class</span> <span class="identifier">MyClass</span><span class="special">;</span></code> then: + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_class</span><span class="special"><</span><span class="identifier">MyClass</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_class</span><span class="special"><</span><span class="identifier">MyClass</span> <span class="keyword">const</span><span class="special">>::</span><span class="identifier">type</span></code> + is the type <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_class</span><span class="special"><</span><span class="identifier">MyClass</span><span class="special">>::</span><span class="identifier">value</span></code> is an integral constant expression + that evaluates to <span class="emphasis"><em>true</em></span>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_class</span><span class="special"><</span><span class="identifier">MyClass</span><span class="special">&>::</span><span class="identifier">value</span></code> is an integral constant expression + that evaluates to <span class="emphasis"><em>false</em></span>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_class</span><span class="special"><</span><span class="identifier">MyClass</span><span class="special">*>::</span><span class="identifier">value</span></code> is an integral constant expression + that evaluates to <span class="emphasis"><em>false</em></span>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_class</span><span class="special"><</span><span class="identifier">T</span><span class="special">>::</span><span class="identifier">value_type</span></code> is the type <code class="computeroutput"><span class="keyword">bool</span></code>. + </p></blockquote></div> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="is_base_of.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="is_complex.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/reference/is_complex.html b/libs/type_traits/doc/html/boost_typetraits/reference/is_complex.html new file mode 100644 index 0000000000..71e9914e04 --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/reference/is_complex.html @@ -0,0 +1,64 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>is_complex</title> +<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../reference.html" title="Alphabetical Reference"> +<link rel="prev" href="is_class.html" title="is_class"> +<link rel="next" href="is_compound.html" title="is_compound"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td> +<td align="center"><a href="../../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="is_class.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="is_compound.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h3 class="title"> +<a name="boost_typetraits.reference.is_complex"></a><a class="link" href="is_complex.html" title="is_complex">is_complex</a> +</h3></div></div></div> +<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">is_complex</span> <span class="special">:</span> <span class="keyword">public</span> <em class="replaceable"><code><a class="link" href="integral_constant.html" title="integral_constant">true_type</a>-or-<a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code></em> <span class="special">{};</span> +</pre> +<p> + <span class="bold"><strong>Inherits:</strong></span> If <code class="computeroutput"><span class="identifier">T</span></code> + is a complex number type then true (of type <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">complex</span><span class="special"><</span><span class="identifier">U</span><span class="special">></span></code> + for some type <code class="computeroutput"><span class="identifier">U</span></code>), otherwise + false. + </p> +<p> + <span class="bold"><strong>C++ Standard Reference:</strong></span> 26.2. + </p> +<p> + <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"> <span class="preprocessor">#include</span> + <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">is_complex</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + </p> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="is_class.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="is_compound.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/reference/is_compound.html b/libs/type_traits/doc/html/boost_typetraits/reference/is_compound.html new file mode 100644 index 0000000000..f54e9ac8ac --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/reference/is_compound.html @@ -0,0 +1,89 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>is_compound</title> +<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../reference.html" title="Alphabetical Reference"> +<link rel="prev" href="is_complex.html" title="is_complex"> +<link rel="next" href="is_const.html" title="is_const"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td> +<td align="center"><a href="../../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="is_complex.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="is_const.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h3 class="title"> +<a name="boost_typetraits.reference.is_compound"></a><a class="link" href="is_compound.html" title="is_compound">is_compound</a> +</h3></div></div></div> +<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">is_compound</span> <span class="special">:</span> <span class="keyword">public</span> <em class="replaceable"><code><a class="link" href="integral_constant.html" title="integral_constant">true_type</a>-or-<a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code></em> <span class="special">{};</span> +</pre> +<p> + <span class="bold"><strong>Inherits:</strong></span> If T is a (possibly cv-qualified) + compound type then inherits from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>, + otherwise inherits from <a class="link" href="integral_constant.html" title="integral_constant">false_type</a>. + Any type that is not a fundamental type is a compound type (see also <a class="link" href="is_fundamental.html" title="is_fundamental">is_fundamental</a>). + </p> +<p> + <span class="bold"><strong>C++ Standard Reference:</strong></span> 3.9.2. + </p> +<p> + <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"> <span class="preprocessor">#include</span> + <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">is_compound</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + </p> +<p> + <span class="bold"><strong>Examples:</strong></span> + </p> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_compound</span><span class="special"><</span><span class="identifier">MyClass</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_compound</span><span class="special"><</span><span class="identifier">MyEnum</span><span class="special">>::</span><span class="identifier">type</span></code> is the type <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_compound</span><span class="special"><</span><span class="keyword">int</span><span class="special">*>::</span><span class="identifier">value</span></code> is an integral constant expression + that evaluates to <span class="emphasis"><em>true</em></span>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_compound</span><span class="special"><</span><span class="keyword">int</span><span class="special">&>::</span><span class="identifier">value</span></code> is an integral constant expression + that evaluates to <span class="emphasis"><em>true</em></span>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_compound</span><span class="special"><</span><span class="keyword">int</span><span class="special">>::</span><span class="identifier">value</span></code> is an integral constant expression + that evaluates to <span class="emphasis"><em>false</em></span>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_compound</span><span class="special"><</span><span class="identifier">T</span><span class="special">>::</span><span class="identifier">value_type</span></code> is the type <code class="computeroutput"><span class="keyword">bool</span></code>. + </p></blockquote></div> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="is_complex.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="is_const.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/reference/is_const.html b/libs/type_traits/doc/html/boost_typetraits/reference/is_const.html new file mode 100644 index 0000000000..38d4bf475c --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/reference/is_const.html @@ -0,0 +1,93 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>is_const</title> +<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../reference.html" title="Alphabetical Reference"> +<link rel="prev" href="is_compound.html" title="is_compound"> +<link rel="next" href="is_convertible.html" title="is_convertible"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td> +<td align="center"><a href="../../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="is_compound.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="is_convertible.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h3 class="title"> +<a name="boost_typetraits.reference.is_const"></a><a class="link" href="is_const.html" title="is_const">is_const</a> +</h3></div></div></div> +<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">is_const</span> <span class="special">:</span> <span class="keyword">public</span> <em class="replaceable"><code><a class="link" href="integral_constant.html" title="integral_constant">true_type</a>-or-<a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code></em> <span class="special">{};</span> +</pre> +<p> + <span class="bold"><strong>Inherits:</strong></span> If T is a (top level) const-qualified + type then inherits from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>, + otherwise inherits from <a class="link" href="integral_constant.html" title="integral_constant">false_type</a>. + </p> +<p> + <span class="bold"><strong>C++ Standard Reference:</strong></span> 3.9.3. + </p> +<p> + <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"> <span class="preprocessor">#include</span> + <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">is_const</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + </p> +<p> + <span class="bold"><strong>Examples:</strong></span> + </p> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_const</span><span class="special"><</span><span class="keyword">int</span> <span class="keyword">const</span><span class="special">></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_const</span><span class="special"><</span><span class="keyword">int</span> <span class="keyword">const</span> <span class="keyword">volatile</span><span class="special">>::</span><span class="identifier">type</span></code> is the type <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_const</span><span class="special"><</span><span class="keyword">int</span><span class="special">*</span> <span class="keyword">const</span><span class="special">>::</span><span class="identifier">value</span></code> + is an integral constant expression that evaluates to <span class="emphasis"><em>true</em></span>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_const</span><span class="special"><</span><span class="keyword">int</span> <span class="keyword">const</span><span class="special">*>::</span><span class="identifier">value</span></code> + is an integral constant expression that evaluates to <span class="emphasis"><em>false</em></span>: + the const-qualifier is not at the top level in this case. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_const</span><span class="special"><</span><span class="keyword">int</span> <span class="keyword">const</span><span class="special">&>::</span><span class="identifier">value</span></code> + is an integral constant expression that evaluates to <span class="emphasis"><em>false</em></span>: + the const-qualifier is not at the top level in this case. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_const</span><span class="special"><</span><span class="keyword">int</span><span class="special">>::</span><span class="identifier">value</span></code> is an integral constant expression + that evaluates to <span class="emphasis"><em>false</em></span>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_const</span><span class="special"><</span><span class="identifier">T</span><span class="special">>::</span><span class="identifier">value_type</span></code> is the type <code class="computeroutput"><span class="keyword">bool</span></code>. + </p></blockquote></div> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="is_compound.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="is_convertible.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/reference/is_convertible.html b/libs/type_traits/doc/html/boost_typetraits/reference/is_convertible.html new file mode 100644 index 0000000000..c7c59ae6b1 --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/reference/is_convertible.html @@ -0,0 +1,133 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>is_convertible</title> +<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../reference.html" title="Alphabetical Reference"> +<link rel="prev" href="is_const.html" title="is_const"> +<link rel="next" href="is_empty.html" title="is_empty"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td> +<td align="center"><a href="../../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="is_const.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="is_empty.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h3 class="title"> +<a name="boost_typetraits.reference.is_convertible"></a><a class="link" href="is_convertible.html" title="is_convertible">is_convertible</a> +</h3></div></div></div> +<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">From</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">To</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">is_convertible</span> <span class="special">:</span> <span class="keyword">public</span> <em class="replaceable"><code><a class="link" href="integral_constant.html" title="integral_constant">true_type</a>-or-<a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code></em> <span class="special">{};</span> +</pre> +<p> + <span class="bold"><strong>Inherits:</strong></span> If an imaginary rvalue of type + <code class="computeroutput"><span class="identifier">From</span></code> is convertible to type + <code class="computeroutput"><span class="identifier">To</span></code> then inherits from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>, + otherwise inherits from <a class="link" href="integral_constant.html" title="integral_constant">false_type</a>. + </p> +<p> + Type From must not be an incomplete type. + </p> +<p> + Type To must not be an incomplete, or function type. + </p> +<p> + No types are considered to be convertible to array types or abstract-class + types. + </p> +<p> + This template can not detect whether a converting-constructor is <code class="computeroutput"><span class="keyword">public</span></code> or not: if type <code class="computeroutput"><span class="identifier">To</span></code> + has a <code class="computeroutput"><span class="keyword">private</span></code> converting constructor + from type <code class="computeroutput"><span class="identifier">From</span></code> then instantiating + <code class="computeroutput"><span class="identifier">is_convertible</span><span class="special"><</span><span class="identifier">From</span><span class="special">,</span> <span class="identifier">To</span><span class="special">></span></code> + will produce a compiler error. For this reason <code class="computeroutput"><span class="identifier">is_convertible</span></code> + can not be used to determine whether a type has a <code class="computeroutput"><span class="keyword">public</span></code> + copy-constructor or not. + </p> +<p> + This template will also produce compiler errors if the conversion is ambiguous, + for example: + </p> +<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{};</span> +<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">:</span> <span class="identifier">A</span> <span class="special">{};</span> +<span class="keyword">struct</span> <span class="identifier">C</span> <span class="special">:</span> <span class="identifier">A</span> <span class="special">{};</span> +<span class="keyword">struct</span> <span class="identifier">D</span> <span class="special">:</span> <span class="identifier">B</span><span class="special">,</span> <span class="identifier">C</span> <span class="special">{};</span> +<span class="comment">// This produces a compiler error, the conversion is ambiguous:</span> +<span class="keyword">bool</span> <span class="keyword">const</span> <span class="identifier">y</span> <span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">is_convertible</span><span class="special"><</span><span class="identifier">D</span><span class="special">*,</span><span class="identifier">A</span><span class="special">*>::</span><span class="identifier">value</span><span class="special">;</span> +</pre> +<p> + <span class="bold"><strong>C++ Standard Reference:</strong></span> 4 and 8.5. + </p> +<p> + <span class="bold"><strong>Compiler Compatibility:</strong></span> 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 <code class="computeroutput"><a class="link" href="is_abstract.html" title="is_abstract">is_abstract</a></code>, + then the template parameter <code class="computeroutput"><span class="identifier">To</span></code> + must not be an abstract type. + </p> +<p> + <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"> <span class="preprocessor">#include</span> + <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">is_convertible</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + </p> +<p> + <span class="bold"><strong>Examples:</strong></span> + </p> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_convertible</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_convertible</span><span class="special"><</span><span class="keyword">const</span> <span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">>::</span><span class="identifier">type</span></code> + is the type <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_convertible</span><span class="special"><</span><span class="keyword">int</span><span class="special">*</span> <span class="keyword">const</span><span class="special">,</span> <span class="keyword">int</span><span class="special">*>::</span><span class="identifier">value</span></code> is an integral constant expression + that evaluates to <span class="emphasis"><em>true</em></span>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_convertible</span><span class="special"><</span><span class="keyword">int</span> <span class="keyword">const</span><span class="special">*,</span> <span class="keyword">int</span><span class="special">*>::</span><span class="identifier">value</span></code> is an integral constant expression + that evaluates to <span class="emphasis"><em>false</em></span>: the conversion would require + a <code class="computeroutput"><span class="keyword">const_cast</span></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_convertible</span><span class="special"><</span><span class="keyword">int</span> <span class="keyword">const</span><span class="special">&,</span> <span class="keyword">long</span><span class="special">>::</span><span class="identifier">value</span></code> + is an integral constant expression that evaluates to <span class="emphasis"><em>true</em></span>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_convertible</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">>::</span><span class="identifier">value</span></code> + is an integral constant expression that evaluates to <span class="emphasis"><em>true</em></span>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_convertible</span><span class="special"><</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">T</span><span class="special">>::</span><span class="identifier">value_type</span></code> + is the type <code class="computeroutput"><span class="keyword">bool</span></code>. + </p></blockquote></div> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="is_const.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="is_empty.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/reference/is_empty.html b/libs/type_traits/doc/html/boost_typetraits/reference/is_empty.html new file mode 100644 index 0000000000..3bcb55a188 --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/reference/is_empty.html @@ -0,0 +1,109 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>is_empty</title> +<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../reference.html" title="Alphabetical Reference"> +<link rel="prev" href="is_convertible.html" title="is_convertible"> +<link rel="next" href="is_enum.html" title="is_enum"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td> +<td align="center"><a href="../../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="is_convertible.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="is_enum.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h3 class="title"> +<a name="boost_typetraits.reference.is_empty"></a><a class="link" href="is_empty.html" title="is_empty">is_empty</a> +</h3></div></div></div> +<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">is_empty</span> <span class="special">:</span> <span class="keyword">public</span> <em class="replaceable"><code><a class="link" href="integral_constant.html" title="integral_constant">true_type</a>-or-<a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code></em> <span class="special">{};</span> +</pre> +<p> + <span class="bold"><strong>Inherits:</strong></span> If T is an empty class type (and + not a union type) then inherits from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>, + otherwise inherits from <a class="link" href="integral_constant.html" title="integral_constant">false_type</a>. + </p> +<p> + <span class="bold"><strong>C++ Standard Reference:</strong></span> 10p5. + </p> +<p> + <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"> <span class="preprocessor">#include</span> + <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">is_empty</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + </p> +<p> + <span class="bold"><strong>Compiler Compatibility:</strong></span> In order to correctly + detect empty classes this trait relies on either: + </p> +<div class="itemizedlist"><ul class="itemizedlist" type="disc"> +<li class="listitem"> + the compiler implementing zero sized empty base classes, or + </li> +<li class="listitem"> + the compiler providing <a class="link" href="../intrinsics.html" title="Support for Compiler Intrinsics">intrinsics</a> + to detect empty classes - this latter case can be tested for by checking + to see if the macro BOOST_IS_EMPTY is defined. + </li> +</ul></div> +<p> + Can not be used with incomplete types. + </p> +<p> + Can not be used with union types, until is_union can be made to work. + </p> +<p> + If the compiler does not support partial-specialization of class templates, + then this template can not be used with abstract types. + </p> +<p> + <span class="bold"><strong>Examples:</strong></span> + </p> +<div class="blockquote"><blockquote class="blockquote"><p> + Given: <code class="computeroutput"><span class="keyword">struct</span> <span class="identifier">empty_class</span> + <span class="special">{};</span></code> + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_empty</span><span class="special"><</span><span class="identifier">empty_class</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_empty</span><span class="special"><</span><span class="identifier">empty_class</span> <span class="keyword">const</span><span class="special">>::</span><span class="identifier">type</span></code> + is the type <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_empty</span><span class="special"><</span><span class="identifier">empty_class</span><span class="special">>::</span><span class="identifier">value</span></code> is an integral constant expression + that evaluates to <span class="emphasis"><em>true</em></span>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_empty</span><span class="special"><</span><span class="identifier">T</span><span class="special">>::</span><span class="identifier">value_type</span></code> is the type <code class="computeroutput"><span class="keyword">bool</span></code>. + </p></blockquote></div> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="is_convertible.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="is_enum.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/reference/is_enum.html b/libs/type_traits/doc/html/boost_typetraits/reference/is_enum.html new file mode 100644 index 0000000000..3b5e127ac8 --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/reference/is_enum.html @@ -0,0 +1,100 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>is_enum</title> +<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../reference.html" title="Alphabetical Reference"> +<link rel="prev" href="is_empty.html" title="is_empty"> +<link rel="next" href="is_floating_point.html" title="is_floating_point"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td> +<td align="center"><a href="../../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="is_empty.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="is_floating_point.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h3 class="title"> +<a name="boost_typetraits.reference.is_enum"></a><a class="link" href="is_enum.html" title="is_enum">is_enum</a> +</h3></div></div></div> +<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">is_enum</span> <span class="special">:</span> <span class="keyword">public</span> <em class="replaceable"><code><a class="link" href="integral_constant.html" title="integral_constant">true_type</a>-or-<a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code></em> <span class="special">{};</span> +</pre> +<p> + <span class="bold"><strong>Inherits:</strong></span> If T is a (possibly cv-qualified) + enum type then inherits from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>, + otherwise inherits from <a class="link" href="integral_constant.html" title="integral_constant">false_type</a>. + </p> +<p> + <span class="bold"><strong>C++ Standard Reference:</strong></span> 3.9.2 and 7.2. + </p> +<p> + <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"> <span class="preprocessor">#include</span> + <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">is_enum</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + </p> +<p> + <span class="bold"><strong>Compiler Compatibility:</strong></span> Requires a correctly + functioning <a class="link" href="is_convertible.html" title="is_convertible">is_convertible</a> + 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. + </p> +<p> + <span class="bold"><strong>Examples:</strong></span> + </p> +<div class="blockquote"><blockquote class="blockquote"><p> + Given: <code class="computeroutput"><span class="keyword">enum</span> <span class="identifier">my_enum</span> + <span class="special">{</span> <span class="identifier">one</span><span class="special">,</span> <span class="identifier">two</span> <span class="special">};</span></code> + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_enum</span><span class="special"><</span><span class="identifier">my_enum</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_enum</span><span class="special"><</span><span class="identifier">my_enum</span> <span class="keyword">const</span><span class="special">>::</span><span class="identifier">type</span></code> + is the type <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_enum</span><span class="special"><</span><span class="identifier">my_enum</span><span class="special">>::</span><span class="identifier">value</span></code> is an integral constant expression + that evaluates to <span class="emphasis"><em>true</em></span>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_enum</span><span class="special"><</span><span class="identifier">my_enum</span><span class="special">&>::</span><span class="identifier">value</span></code> is an integral constant expression + that evaluates to <span class="emphasis"><em>false</em></span>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_enum</span><span class="special"><</span><span class="identifier">my_enum</span><span class="special">*>::</span><span class="identifier">value</span></code> is an integral constant expression + that evaluates to <span class="emphasis"><em>false</em></span>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_enum</span><span class="special"><</span><span class="identifier">T</span><span class="special">>::</span><span class="identifier">value_type</span></code> is the type <code class="computeroutput"><span class="keyword">bool</span></code>. + </p></blockquote></div> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="is_empty.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="is_floating_point.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/reference/is_floating_point.html b/libs/type_traits/doc/html/boost_typetraits/reference/is_floating_point.html new file mode 100644 index 0000000000..e3628019b7 --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/reference/is_floating_point.html @@ -0,0 +1,80 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>is_floating_point</title> +<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../reference.html" title="Alphabetical Reference"> +<link rel="prev" href="is_enum.html" title="is_enum"> +<link rel="next" href="is_function.html" title="is_function"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td> +<td align="center"><a href="../../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="is_enum.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="is_function.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h3 class="title"> +<a name="boost_typetraits.reference.is_floating_point"></a><a class="link" href="is_floating_point.html" title="is_floating_point">is_floating_point</a> +</h3></div></div></div> +<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">is_floating_point</span> <span class="special">:</span> <span class="keyword">public</span> <em class="replaceable"><code><a class="link" href="integral_constant.html" title="integral_constant">true_type</a>-or-<a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code></em> <span class="special">{};</span> +</pre> +<p> + <span class="bold"><strong>Inherits:</strong></span> If T is a (possibly cv-qualified) + floating point type then inherits from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>, + otherwise inherits from <a class="link" href="integral_constant.html" title="integral_constant">false_type</a>. + </p> +<p> + <span class="bold"><strong>C++ Standard Reference:</strong></span> 3.9.1p8. + </p> +<p> + <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"> <span class="preprocessor">#include</span> + <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">is_floating_point</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + </p> +<p> + <span class="bold"><strong>Examples:</strong></span> + </p> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_floating_point</span><span class="special"><</span><span class="keyword">float</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_floating_point</span><span class="special"><</span><span class="keyword">double</span><span class="special">>::</span><span class="identifier">type</span></code> is the type <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_floating_point</span><span class="special"><</span><span class="keyword">long</span> <span class="keyword">double</span><span class="special">>::</span><span class="identifier">value</span></code> + is an integral constant expression that evaluates to <span class="emphasis"><em>true</em></span>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_floating_point</span><span class="special"><</span><span class="identifier">T</span><span class="special">>::</span><span class="identifier">value_type</span></code> is the type <code class="computeroutput"><span class="keyword">bool</span></code>. + </p></blockquote></div> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="is_enum.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="is_function.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/reference/is_function.html b/libs/type_traits/doc/html/boost_typetraits/reference/is_function.html new file mode 100644 index 0000000000..64eca5f33c --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/reference/is_function.html @@ -0,0 +1,148 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>is_function</title> +<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../reference.html" title="Alphabetical Reference"> +<link rel="prev" href="is_floating_point.html" title="is_floating_point"> +<link rel="next" href="is_fundamental.html" title="is_fundamental"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td> +<td align="center"><a href="../../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="is_floating_point.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="is_fundamental.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h3 class="title"> +<a name="boost_typetraits.reference.is_function"></a><a class="link" href="is_function.html" title="is_function">is_function</a> +</h3></div></div></div> +<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">is_function</span> <span class="special">:</span> <span class="keyword">public</span> <em class="replaceable"><code><a class="link" href="integral_constant.html" title="integral_constant">true_type</a>-or-<a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code></em> <span class="special">{};</span> +</pre> +<p> + <span class="bold"><strong>Inherits:</strong></span> If T is a (possibly cv-qualified) + function type then inherits from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>, + otherwise inherits from <a class="link" href="integral_constant.html" title="integral_constant">false_type</a>. + Note that this template does not detect <span class="emphasis"><em>pointers to functions</em></span>, + or <span class="emphasis"><em>references to functions</em></span>, these are detected by <a class="link" href="is_pointer.html" title="is_pointer">is_pointer</a> and <a class="link" href="is_reference.html" title="is_reference">is_reference</a> respectively: + </p> +<pre class="programlisting"><span class="keyword">typedef</span> <span class="keyword">int</span> <span class="identifier">f1</span><span class="special">();</span> <span class="comment">// f1 is of function type.</span> +<span class="keyword">typedef</span> <span class="keyword">int</span> <span class="special">(</span><span class="identifier">f2</span><span class="special">*)();</span> <span class="comment">// f2 is a pointer to a function.</span> +<span class="keyword">typedef</span> <span class="keyword">int</span> <span class="special">(</span><span class="identifier">f3</span><span class="special">&)();</span> <span class="comment">// f3 is a reference to a function.</span> +</pre> +<p> + <span class="bold"><strong>C++ Standard Reference:</strong></span> 3.9.2p1 and 8.3.5. + </p> +<p> + <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"> <span class="preprocessor">#include</span> + <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">is_function</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + </p> +<p> + <span class="bold"><strong>Examples:</strong></span> + </p> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_function</span><span class="special"><</span><span class="keyword">int</span> <span class="special">(</span><span class="keyword">void</span><span class="special">)></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_function</span><span class="special"><</span><span class="keyword">long</span> <span class="special">(</span><span class="keyword">double</span><span class="special">,</span> <span class="keyword">int</span><span class="special">)>::</span><span class="identifier">type</span></code> is the type <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_function</span><span class="special"><</span><span class="keyword">long</span> <span class="special">(</span><span class="keyword">double</span><span class="special">,</span> <span class="keyword">int</span><span class="special">)>::</span><span class="identifier">value</span></code> is an integral constant expression + that evaluates to <span class="emphasis"><em>true</em></span>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_function</span><span class="special"><</span><span class="keyword">long</span> <span class="special">(*)(</span><span class="keyword">double</span><span class="special">,</span> <span class="keyword">int</span><span class="special">)>::</span><span class="identifier">value</span></code> is an integral constant expression + that evaluates to <span class="emphasis"><em>false</em></span>: the argument in this case + is a pointer type, not a function type. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_function</span><span class="special"><</span><span class="keyword">long</span> <span class="special">(&)(</span><span class="keyword">double</span><span class="special">,</span> <span class="keyword">int</span><span class="special">)>::</span><span class="identifier">value</span></code> is an integral constant expression + that evaluates to <span class="emphasis"><em>false</em></span>: the argument in this case + is a reference to a function, not a function type. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_function</span><span class="special"><</span><span class="keyword">long</span> <span class="special">(</span><span class="identifier">MyClass</span><span class="special">::*)(</span><span class="keyword">double</span><span class="special">,</span> <span class="keyword">int</span><span class="special">)>::</span><span class="identifier">value</span></code> is an integral constant expression + that evaluates to <span class="emphasis"><em>false</em></span>: the argument in this case + is a pointer to a member function. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_function</span><span class="special"><</span><span class="identifier">T</span><span class="special">>::</span><span class="identifier">value_type</span></code> is the type <code class="computeroutput"><span class="keyword">bool</span></code>. + </p></blockquote></div> +<div class="tip"><table border="0" summary="Tip"> +<tr> +<td rowspan="2" align="center" valign="top" width="25"><img alt="[Tip]" src="../../../../../../doc/src/images/tip.png"></td> +<th align="left">Tip</th> +</tr> +<tr><td align="left" valign="top"> +<p> + Don't confuse function-types with pointers to functions: + </p> +<p> + <code class="computeroutput"><span class="keyword">typedef</span> <span class="keyword">int</span> + <span class="identifier">f</span><span class="special">(</span><span class="keyword">double</span><span class="special">);</span></code> + </p> +<p> + defines a function type, + </p> +<p> + <code class="computeroutput"><span class="identifier">f</span> <span class="identifier">foo</span><span class="special">;</span></code> + </p> +<p> + declares a prototype for a function of type <code class="computeroutput"><span class="identifier">f</span></code>, + </p> +<p> + <code class="computeroutput"><span class="identifier">f</span><span class="special">*</span> + <span class="identifier">pf</span> <span class="special">=</span> + <span class="identifier">foo</span><span class="special">;</span></code> + </p> +<p> + <code class="computeroutput"><span class="identifier">f</span><span class="special">&</span> + <span class="identifier">fr</span> <span class="special">=</span> + <span class="identifier">foo</span><span class="special">;</span></code> + </p> +<p> + declares a pointer and a reference to the function <code class="computeroutput"><span class="identifier">foo</span></code>. + </p> +<p> + If you want to detect whether some type is a pointer-to-function then use: + </p> +<p> + <code class="computeroutput"><a class="link" href="is_function.html" title="is_function">is_function</a><span class="special"><</span><a class="link" href="remove_pointer.html" title="remove_pointer">remove_pointer</a><span class="special"><</span><span class="identifier">T</span><span class="special">>::</span><span class="identifier">type</span><span class="special">>::</span><span class="identifier">value</span> + <span class="special">&&</span> <a class="link" href="is_pointer.html" title="is_pointer">is_pointer</a><span class="special"><</span><span class="identifier">T</span><span class="special">>::</span><span class="identifier">value</span></code> + </p> +<p> + or for pointers to member functions you can just use <a class="link" href="is_member_function_pointer.html" title="is_member_function_pointer">is_member_function_pointer</a> + directly. + </p> +</td></tr> +</table></div> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="is_floating_point.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="is_fundamental.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/reference/is_fundamental.html b/libs/type_traits/doc/html/boost_typetraits/reference/is_fundamental.html new file mode 100644 index 0000000000..ad12f467b9 --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/reference/is_fundamental.html @@ -0,0 +1,85 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>is_fundamental</title> +<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../reference.html" title="Alphabetical Reference"> +<link rel="prev" href="is_function.html" title="is_function"> +<link rel="next" href="is_integral.html" title="is_integral"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td> +<td align="center"><a href="../../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="is_function.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="is_integral.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h3 class="title"> +<a name="boost_typetraits.reference.is_fundamental"></a><a class="link" href="is_fundamental.html" title="is_fundamental">is_fundamental</a> +</h3></div></div></div> +<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">is_fundamental</span> <span class="special">:</span> <span class="keyword">public</span> <em class="replaceable"><code><a class="link" href="integral_constant.html" title="integral_constant">true_type</a>-or-<a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code></em> <span class="special">{};</span> +</pre> +<p> + <span class="bold"><strong>Inherits:</strong></span> If T is a (possibly cv-qualified) + fundamental type then inherits from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>, + otherwise inherits from <a class="link" href="integral_constant.html" title="integral_constant">false_type</a>. + Fundamental types include integral, floating point and void types (see also + <a class="link" href="is_integral.html" title="is_integral">is_integral</a>, + <a class="link" href="is_floating_point.html" title="is_floating_point">is_floating_point</a> + and <a class="link" href="is_void.html" title="is_void">is_void</a>) + </p> +<p> + <span class="bold"><strong>C++ Standard Reference:</strong></span> 3.9.1. + </p> +<p> + <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"> <span class="preprocessor">#include</span> + <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">is_fundamental</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + </p> +<p> + <span class="bold"><strong>Examples:</strong></span> + </p> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_fundamental</span><span class="special"><</span><span class="keyword">int</span><span class="special">)></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_fundamental</span><span class="special"><</span><span class="keyword">double</span> <span class="keyword">const</span><span class="special">>::</span><span class="identifier">type</span></code> + is the type <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_fundamental</span><span class="special"><</span><span class="keyword">void</span><span class="special">>::</span><span class="identifier">value</span></code> is an integral constant expression + that evaluates to <span class="emphasis"><em>true</em></span>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_fundamental</span><span class="special"><</span><span class="identifier">T</span><span class="special">>::</span><span class="identifier">value_type</span></code> is the type <code class="computeroutput"><span class="keyword">bool</span></code>. + </p></blockquote></div> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="is_function.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="is_integral.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/reference/is_integral.html b/libs/type_traits/doc/html/boost_typetraits/reference/is_integral.html new file mode 100644 index 0000000000..535a748d51 --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/reference/is_integral.html @@ -0,0 +1,81 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>is_integral</title> +<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../reference.html" title="Alphabetical Reference"> +<link rel="prev" href="is_fundamental.html" title="is_fundamental"> +<link rel="next" href="is_lvalue_reference.html" title="is_lvalue_reference"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td> +<td align="center"><a href="../../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="is_fundamental.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="is_lvalue_reference.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h3 class="title"> +<a name="boost_typetraits.reference.is_integral"></a><a class="link" href="is_integral.html" title="is_integral">is_integral</a> +</h3></div></div></div> +<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">is_integral</span> <span class="special">:</span> <span class="keyword">public</span> <em class="replaceable"><code><a class="link" href="integral_constant.html" title="integral_constant">true_type</a>-or-<a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code></em> <span class="special">{};</span> +</pre> +<p> + <span class="bold"><strong>Inherits:</strong></span> If T is a (possibly cv-qualified) + integral type then inherits from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>, + otherwise inherits from <a class="link" href="integral_constant.html" title="integral_constant">false_type</a>. + </p> +<p> + <span class="bold"><strong>C++ Standard Reference:</strong></span> 3.9.1p7. + </p> +<p> + <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"> <span class="preprocessor">#include</span> + <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">is_integral</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + </p> +<p> + <span class="bold"><strong>Examples:</strong></span> + </p> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_integral</span><span class="special"><</span><span class="keyword">int</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_integral</span><span class="special"><</span><span class="keyword">const</span> <span class="keyword">char</span><span class="special">>::</span><span class="identifier">type</span></code> + is the type <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_integral</span><span class="special"><</span><span class="keyword">long</span><span class="special">>::</span><span class="identifier">value</span></code> is an integral constant expression + that evaluates to <span class="emphasis"><em>true</em></span>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_integral</span><span class="special"><</span><span class="identifier">T</span><span class="special">>::</span><span class="identifier">value_type</span></code> is the type <code class="computeroutput"><span class="keyword">bool</span></code>. + </p></blockquote></div> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="is_fundamental.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="is_lvalue_reference.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/reference/is_lvalue_reference.html b/libs/type_traits/doc/html/boost_typetraits/reference/is_lvalue_reference.html new file mode 100644 index 0000000000..367a06c65f --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/reference/is_lvalue_reference.html @@ -0,0 +1,92 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>is_lvalue_reference</title> +<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../reference.html" title="Alphabetical Reference"> +<link rel="prev" href="is_integral.html" title="is_integral"> +<link rel="next" href="is_member_function_pointer.html" title="is_member_function_pointer"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td> +<td align="center"><a href="../../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="is_integral.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="is_member_function_pointer.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h3 class="title"> +<a name="boost_typetraits.reference.is_lvalue_reference"></a><a class="link" href="is_lvalue_reference.html" title="is_lvalue_reference">is_lvalue_reference</a> +</h3></div></div></div> +<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">is_lvalue_reference</span> <span class="special">:</span> <span class="keyword">public</span> <em class="replaceable"><code><a class="link" href="integral_constant.html" title="integral_constant">true_type</a>-or-<a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code></em> <span class="special">{};</span> +</pre> +<p> + <span class="bold"><strong>Inherits:</strong></span> If T is an lvalue reference type + then inherits from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>, + otherwise inherits from <a class="link" href="integral_constant.html" title="integral_constant">false_type</a>. + </p> +<p> + <span class="bold"><strong>C++ Standard Reference:</strong></span> 3.9.2 and 8.3.2. + </p> +<p> + <span class="bold"><strong>Compiler Compatibility:</strong></span> 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. + </p> +<p> + <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"> <span class="preprocessor">#include</span> + <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">is_lvalue_reference</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + </p> +<p> + <span class="bold"><strong>Examples:</strong></span> + </p> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_lvalue_reference</span><span class="special"><</span><span class="keyword">int</span><span class="special">&></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_lvalue_reference</span><span class="special"><</span><span class="keyword">int</span> <span class="keyword">const</span><span class="special">&>::</span><span class="identifier">type</span></code> + is the type <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_lvalue_reference</span><span class="special"><</span><span class="keyword">int</span> <span class="keyword">const</span><span class="special">&&>::</span><span class="identifier">type</span></code> + is the type <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_lvalue_reference</span><span class="special"><</span><span class="keyword">int</span> <span class="special">(&)(</span><span class="keyword">long</span><span class="special">)>::</span><span class="identifier">value</span></code> is an integral constant expression + that evaluates to <span class="emphasis"><em>true</em></span> (the argument in this case + is a reference to a function). + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_lvalue_reference</span><span class="special"><</span><span class="identifier">T</span><span class="special">>::</span><span class="identifier">value_type</span></code> is the type <code class="computeroutput"><span class="keyword">bool</span></code>. + </p></blockquote></div> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="is_integral.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="is_member_function_pointer.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/reference/is_member_function_pointer.html b/libs/type_traits/doc/html/boost_typetraits/reference/is_member_function_pointer.html new file mode 100644 index 0000000000..b1c0ce477a --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/reference/is_member_function_pointer.html @@ -0,0 +1,88 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>is_member_function_pointer</title> +<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../reference.html" title="Alphabetical Reference"> +<link rel="prev" href="is_lvalue_reference.html" title="is_lvalue_reference"> +<link rel="next" href="is_member_object_pointer.html" title="is_member_object_pointer"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td> +<td align="center"><a href="../../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="is_lvalue_reference.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="is_member_object_pointer.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h3 class="title"> +<a name="boost_typetraits.reference.is_member_function_pointer"></a><a class="link" href="is_member_function_pointer.html" title="is_member_function_pointer">is_member_function_pointer</a> +</h3></div></div></div> +<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">is_member_function_pointer</span> <span class="special">:</span> <span class="keyword">public</span> <em class="replaceable"><code><a class="link" href="integral_constant.html" title="integral_constant">true_type</a>-or-<a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code></em> <span class="special">{};</span> +</pre> +<p> + <span class="bold"><strong>Inherits:</strong></span> If T is a (possibly cv-qualified) + pointer to a member function then inherits from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>, + otherwise inherits from <a class="link" href="integral_constant.html" title="integral_constant">false_type</a>. + </p> +<p> + <span class="bold"><strong>C++ Standard Reference:</strong></span> 3.9.2 and 8.3.3. + </p> +<p> + <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"> <span class="preprocessor">#include</span> + <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">is_member_function_pointer</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + </p> +<p> + <span class="bold"><strong>Examples:</strong></span> + </p> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_member_function_pointer</span><span class="special"><</span><span class="keyword">int</span> <span class="special">(</span><span class="identifier">MyClass</span><span class="special">::*)(</span><span class="keyword">void</span><span class="special">)></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_member_function_pointer</span><span class="special"><</span><span class="keyword">int</span> <span class="special">(</span><span class="identifier">MyClass</span><span class="special">::*)(</span><span class="keyword">char</span><span class="special">)>::</span><span class="identifier">type</span></code> + is the type <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_member_function_pointer</span><span class="special"><</span><span class="keyword">int</span> <span class="special">(</span><span class="identifier">MyClass</span><span class="special">::*)(</span><span class="keyword">void</span><span class="special">)</span><span class="keyword">const</span><span class="special">>::</span><span class="identifier">value</span></code> is an integral constant expression + that evaluates to <span class="emphasis"><em>true</em></span>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_member_function_pointer</span><span class="special"><</span><span class="keyword">int</span> <span class="special">(</span><span class="identifier">MyClass</span><span class="special">::*)>::</span><span class="identifier">value</span></code> + is an integral constant expression that evaluates to <span class="emphasis"><em>false</em></span>: + the argument in this case is a pointer to a data member and not a member + function, see <a class="link" href="is_member_object_pointer.html" title="is_member_object_pointer">is_member_object_pointer</a> + and <a class="link" href="is_member_pointer.html" title="is_member_pointer">is_member_pointer</a> + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_member_function_pointer</span><span class="special"><</span><span class="identifier">T</span><span class="special">>::</span><span class="identifier">value_type</span></code> + is the type <code class="computeroutput"><span class="keyword">bool</span></code>. + </p></blockquote></div> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="is_lvalue_reference.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="is_member_object_pointer.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/reference/is_member_object_pointer.html b/libs/type_traits/doc/html/boost_typetraits/reference/is_member_object_pointer.html new file mode 100644 index 0000000000..daa54d9c3f --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/reference/is_member_object_pointer.html @@ -0,0 +1,88 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>is_member_object_pointer</title> +<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../reference.html" title="Alphabetical Reference"> +<link rel="prev" href="is_member_function_pointer.html" title="is_member_function_pointer"> +<link rel="next" href="is_member_pointer.html" title="is_member_pointer"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td> +<td align="center"><a href="../../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="is_member_function_pointer.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="is_member_pointer.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h3 class="title"> +<a name="boost_typetraits.reference.is_member_object_pointer"></a><a class="link" href="is_member_object_pointer.html" title="is_member_object_pointer">is_member_object_pointer</a> +</h3></div></div></div> +<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">is_member_object_pointer</span> <span class="special">:</span> <span class="keyword">public</span> <em class="replaceable"><code><a class="link" href="integral_constant.html" title="integral_constant">true_type</a>-or-<a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code></em> <span class="special">{};</span> +</pre> +<p> + <span class="bold"><strong>Inherits:</strong></span> If T is a (possibly cv-qualified) + pointer to a member object (a data member) then inherits from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>, + otherwise inherits from <a class="link" href="integral_constant.html" title="integral_constant">false_type</a>. + </p> +<p> + <span class="bold"><strong>C++ Standard Reference:</strong></span> 3.9.2 and 8.3.3. + </p> +<p> + <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"> <span class="preprocessor">#include</span> + <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">is_member_object_pointer</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + </p> +<p> + <span class="bold"><strong>Examples:</strong></span> + </p> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_member_object_pointer</span><span class="special"><</span><span class="keyword">int</span> <span class="special">(</span><span class="identifier">MyClass</span><span class="special">::*)></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_member_object_pointer</span><span class="special"><</span><span class="keyword">double</span> <span class="special">(</span><span class="identifier">MyClass</span><span class="special">::*)>::</span><span class="identifier">type</span></code> + is the type <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_member_object_pointer</span><span class="special"><</span><span class="keyword">const</span> <span class="keyword">int</span> <span class="special">(</span><span class="identifier">MyClass</span><span class="special">::*)>::</span><span class="identifier">value</span></code> + is an integral constant expression that evaluates to <span class="emphasis"><em>true</em></span>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_member_object_pointer</span><span class="special"><</span><span class="keyword">int</span> <span class="special">(</span><span class="identifier">MyClass</span><span class="special">::*)(</span><span class="keyword">void</span><span class="special">)>::</span><span class="identifier">value</span></code> + is an integral constant expression that evaluates to <span class="emphasis"><em>false</em></span>: + the argument in this case is a pointer to a member function and not a member + object, see <a class="link" href="is_member_function_pointer.html" title="is_member_function_pointer">is_member_function_pointer</a> + and <a class="link" href="is_member_pointer.html" title="is_member_pointer">is_member_pointer</a> + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_member_object_pointer</span><span class="special"><</span><span class="identifier">T</span><span class="special">>::</span><span class="identifier">value_type</span></code> + is the type <code class="computeroutput"><span class="keyword">bool</span></code>. + </p></blockquote></div> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="is_member_function_pointer.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="is_member_pointer.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/reference/is_member_pointer.html b/libs/type_traits/doc/html/boost_typetraits/reference/is_member_pointer.html new file mode 100644 index 0000000000..f5d3dc11b6 --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/reference/is_member_pointer.html @@ -0,0 +1,81 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>is_member_pointer</title> +<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../reference.html" title="Alphabetical Reference"> +<link rel="prev" href="is_member_object_pointer.html" title="is_member_object_pointer"> +<link rel="next" href="is_object.html" title="is_object"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td> +<td align="center"><a href="../../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="is_member_object_pointer.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="is_object.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h3 class="title"> +<a name="boost_typetraits.reference.is_member_pointer"></a><a class="link" href="is_member_pointer.html" title="is_member_pointer">is_member_pointer</a> +</h3></div></div></div> +<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">is_member_pointer</span> <span class="special">:</span> <span class="keyword">public</span> <em class="replaceable"><code><a class="link" href="integral_constant.html" title="integral_constant">true_type</a>-or-<a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code></em> <span class="special">{};</span> +</pre> +<p> + <span class="bold"><strong>Inherits:</strong></span> If T is a (possibly cv-qualified) + pointer to a member (either a function or a data member) then inherits from + <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>, + otherwise inherits from <a class="link" href="integral_constant.html" title="integral_constant">false_type</a>. + </p> +<p> + <span class="bold"><strong>C++ Standard Reference:</strong></span> 3.9.2 and 8.3.3. + </p> +<p> + <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"> <span class="preprocessor">#include</span> + <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">is_member_pointer</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + </p> +<p> + <span class="bold"><strong>Examples:</strong></span> + </p> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_member_pointer</span><span class="special"><</span><span class="keyword">int</span> <span class="special">(</span><span class="identifier">MyClass</span><span class="special">::*)></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_member_pointer</span><span class="special"><</span><span class="keyword">int</span> <span class="special">(</span><span class="identifier">MyClass</span><span class="special">::*)(</span><span class="keyword">char</span><span class="special">)>::</span><span class="identifier">type</span></code> + is the type <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_member_pointer</span><span class="special"><</span><span class="keyword">int</span> <span class="special">(</span><span class="identifier">MyClass</span><span class="special">::*)(</span><span class="keyword">void</span><span class="special">)</span><span class="keyword">const</span><span class="special">>::</span><span class="identifier">value</span></code> is an integral constant expression + that evaluates to <span class="emphasis"><em>true</em></span>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_member_pointer</span><span class="special"><</span><span class="identifier">T</span><span class="special">>::</span><span class="identifier">value_type</span></code> is the type <code class="computeroutput"><span class="keyword">bool</span></code>. + </p></blockquote></div> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="is_member_object_pointer.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="is_object.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/reference/is_object.html b/libs/type_traits/doc/html/boost_typetraits/reference/is_object.html new file mode 100644 index 0000000000..f268cad247 --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/reference/is_object.html @@ -0,0 +1,99 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>is_object</title> +<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../reference.html" title="Alphabetical Reference"> +<link rel="prev" href="is_member_pointer.html" title="is_member_pointer"> +<link rel="next" href="is_pod.html" title="is_pod"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td> +<td align="center"><a href="../../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="is_member_pointer.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="is_pod.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h3 class="title"> +<a name="boost_typetraits.reference.is_object"></a><a class="link" href="is_object.html" title="is_object">is_object</a> +</h3></div></div></div> +<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">is_object</span> <span class="special">:</span> <span class="keyword">public</span> <em class="replaceable"><code><a class="link" href="integral_constant.html" title="integral_constant">true_type</a>-or-<a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code></em> <span class="special">{};</span> +</pre> +<p> + <span class="bold"><strong>Inherits:</strong></span> If T is a (possibly cv-qualified) + object type then inherits from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>, + otherwise inherits from <a class="link" href="integral_constant.html" title="integral_constant">false_type</a>. + All types are object types except references, void, and function types. + </p> +<p> + <span class="bold"><strong>C++ Standard Reference:</strong></span> 3.9p9. + </p> +<p> + <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"> <span class="preprocessor">#include</span> + <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">is_object</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + </p> +<p> + <span class="bold"><strong>Examples:</strong></span> + </p> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_object</span><span class="special"><</span><span class="keyword">int</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_object</span><span class="special"><</span><span class="keyword">int</span><span class="special">*>::</span><span class="identifier">type</span></code> is the type <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_object</span><span class="special"><</span><span class="keyword">int</span> <span class="special">(*)(</span><span class="keyword">void</span><span class="special">)>::</span><span class="identifier">value</span></code> is an integral constant expression + that evaluates to <span class="emphasis"><em>true</em></span>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_object</span><span class="special"><</span><span class="keyword">int</span> <span class="special">(</span><span class="identifier">MyClass</span><span class="special">::*)(</span><span class="keyword">void</span><span class="special">)</span><span class="keyword">const</span><span class="special">>::</span><span class="identifier">value</span></code> is an integral constant expression + that evaluates to <span class="emphasis"><em>true</em></span>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_object</span><span class="special"><</span><span class="keyword">int</span> <span class="special">&>::</span><span class="identifier">value</span></code> is an integral constant expression + that evaluates to <span class="emphasis"><em>false</em></span>: reference types are not objects + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_object</span><span class="special"><</span><span class="keyword">int</span> <span class="special">(</span><span class="keyword">double</span><span class="special">)>::</span><span class="identifier">value</span></code> + is an integral constant expression that evaluates to <span class="emphasis"><em>false</em></span>: + function types are not objects + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_object</span><span class="special"><</span><span class="keyword">const</span> <span class="keyword">void</span><span class="special">>::</span><span class="identifier">value</span></code> + is an integral constant expression that evaluates to <span class="emphasis"><em>false</em></span>: + void is not an object type + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_object</span><span class="special"><</span><span class="identifier">T</span><span class="special">>::</span><span class="identifier">value_type</span></code> is the type <code class="computeroutput"><span class="keyword">bool</span></code>. + </p></blockquote></div> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="is_member_pointer.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="is_pod.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/reference/is_pod.html b/libs/type_traits/doc/html/boost_typetraits/reference/is_pod.html new file mode 100644 index 0000000000..d4e680c047 --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/reference/is_pod.html @@ -0,0 +1,110 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>is_pod</title> +<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../reference.html" title="Alphabetical Reference"> +<link rel="prev" href="is_object.html" title="is_object"> +<link rel="next" href="is_pointer.html" title="is_pointer"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td> +<td align="center"><a href="../../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="is_object.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="is_pointer.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h3 class="title"> +<a name="boost_typetraits.reference.is_pod"></a><a class="link" href="is_pod.html" title="is_pod">is_pod</a> +</h3></div></div></div> +<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">is_pod</span> <span class="special">:</span> <span class="keyword">public</span> <em class="replaceable"><code><a class="link" href="integral_constant.html" title="integral_constant">true_type</a>-or-<a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code></em> <span class="special">{};</span> +</pre> +<p> + <span class="bold"><strong>Inherits:</strong></span> If T is a (possibly cv-qualified) + POD type then inherits from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>, + otherwise inherits from <a class="link" href="integral_constant.html" title="integral_constant">false_type</a>. + </p> +<p> + 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. + </p> +<p> + <span class="bold"><strong>C++ Standard Reference:</strong></span> 3.9p10 and 9p4 (Note + that POD's are also aggregates, see 8.5.1). + </p> +<p> + <span class="bold"><strong>Compiler Compatibility:</strong></span> If the compiler + does not support partial-specialization of class templates, then this template + can not be used with function types. + </p> +<p> + 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 2011) compilers more recent than Visual C++ 8, + GCC-4.3, Greenhills 6.0, Intel-11.0, and Codegear have the necessary compiler + <a class="link" href="../intrinsics.html" title="Support for Compiler Intrinsics">intrinsics</a> to ensure that + this trait "just works". You may also test to see if the necessary + <a class="link" href="../intrinsics.html" title="Support for Compiler Intrinsics">intrinsics</a> are available + by checking to see if the macro <code class="computeroutput"><span class="identifier">BOOST_IS_POD</span></code> + is defined. + </p> +<p> + <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"> <span class="preprocessor">#include</span> + <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">is_pod</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + </p> +<p> + <span class="bold"><strong>Examples:</strong></span> + </p> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_pod</span><span class="special"><</span><span class="keyword">int</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_pod</span><span class="special"><</span><span class="keyword">char</span><span class="special">*>::</span><span class="identifier">type</span></code> is the type <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_pod</span><span class="special"><</span><span class="keyword">int</span> <span class="special">(*)(</span><span class="keyword">long</span><span class="special">)>::</span><span class="identifier">value</span></code> is an integral constant expression + that evaluates to <span class="emphasis"><em>true</em></span>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_pod</span><span class="special"><</span><span class="identifier">MyClass</span><span class="special">>::</span><span class="identifier">value</span></code> is an integral constant expression + that evaluates to <span class="emphasis"><em>false</em></span>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_pod</span><span class="special"><</span><span class="identifier">T</span><span class="special">>::</span><span class="identifier">value_type</span></code> is the type <code class="computeroutput"><span class="keyword">bool</span></code>. + </p></blockquote></div> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="is_object.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="is_pointer.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/reference/is_pointer.html b/libs/type_traits/doc/html/boost_typetraits/reference/is_pointer.html new file mode 100644 index 0000000000..3c7fbb678c --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/reference/is_pointer.html @@ -0,0 +1,106 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>is_pointer</title> +<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../reference.html" title="Alphabetical Reference"> +<link rel="prev" href="is_pod.html" title="is_pod"> +<link rel="next" href="is_polymorphic.html" title="is_polymorphic"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td> +<td align="center"><a href="../../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="is_pod.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="is_polymorphic.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h3 class="title"> +<a name="boost_typetraits.reference.is_pointer"></a><a class="link" href="is_pointer.html" title="is_pointer">is_pointer</a> +</h3></div></div></div> +<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">is_pointer</span> <span class="special">:</span> <span class="keyword">public</span> <em class="replaceable"><code><a class="link" href="integral_constant.html" title="integral_constant">true_type</a>-or-<a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code></em> <span class="special">{};</span> +</pre> +<p> + <span class="bold"><strong>Inherits:</strong></span> If T is a (possibly cv-qualified) + pointer type (includes function pointers, but excludes pointers to members) + then inherits from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>, + otherwise inherits from <a class="link" href="integral_constant.html" title="integral_constant">false_type</a>. + </p> +<p> + <span class="bold"><strong>C++ Standard Reference:</strong></span> 3.9.2p2 and 8.3.1. + </p> +<p> + <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"> <span class="preprocessor">#include</span> + <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">is_pointer</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + </p> +<p> + <span class="bold"><strong>Examples:</strong></span> + </p> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_pointer</span><span class="special"><</span><span class="keyword">int</span><span class="special">*></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_pointer</span><span class="special"><</span><span class="keyword">char</span><span class="special">*</span> <span class="keyword">const</span><span class="special">>::</span><span class="identifier">type</span></code> + is the type <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_pointer</span><span class="special"><</span><span class="keyword">int</span> <span class="special">(*)(</span><span class="keyword">long</span><span class="special">)>::</span><span class="identifier">value</span></code> is an integral constant expression + that evaluates to <span class="emphasis"><em>true</em></span>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_pointer</span><span class="special"><</span><span class="keyword">int</span> <span class="special">(</span><span class="identifier">MyClass</span><span class="special">::*)(</span><span class="keyword">long</span><span class="special">)>::</span><span class="identifier">value</span></code> + is an integral constant expression that evaluates to <span class="emphasis"><em>false</em></span>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_pointer</span><span class="special"><</span><span class="keyword">int</span> <span class="special">(</span><span class="identifier">MyClass</span><span class="special">::*)>::</span><span class="identifier">value</span></code> + is an integral constant expression that evaluates to <span class="emphasis"><em>false</em></span>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_pointer</span><span class="special"><</span><span class="identifier">T</span><span class="special">>::</span><span class="identifier">value_type</span></code> is the type <code class="computeroutput"><span class="keyword">bool</span></code>. + </p></blockquote></div> +<div class="important"><table border="0" summary="Important"> +<tr> +<td rowspan="2" align="center" valign="top" width="25"><img alt="[Important]" src="../../../../../../doc/src/images/important.png"></td> +<th align="left">Important</th> +</tr> +<tr><td align="left" valign="top"><p> + <code class="computeroutput"><span class="identifier">is_pointer</span></code> detects "real" + pointer types only, and <span class="emphasis"><em>not</em></span> smart pointers. Users + should not specialise <code class="computeroutput"><span class="identifier">is_pointer</span></code> + 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. + </p></td></tr> +</table></div> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="is_pod.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="is_polymorphic.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/reference/is_polymorphic.html b/libs/type_traits/doc/html/boost_typetraits/reference/is_polymorphic.html new file mode 100644 index 0000000000..194ffbe179 --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/reference/is_polymorphic.html @@ -0,0 +1,91 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>is_polymorphic</title> +<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../reference.html" title="Alphabetical Reference"> +<link rel="prev" href="is_pointer.html" title="is_pointer"> +<link rel="next" href="is_reference.html" title="is_reference"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td> +<td align="center"><a href="../../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="is_pointer.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="is_reference.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h3 class="title"> +<a name="boost_typetraits.reference.is_polymorphic"></a><a class="link" href="is_polymorphic.html" title="is_polymorphic">is_polymorphic</a> +</h3></div></div></div> +<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">is_polymorphic</span> <span class="special">:</span> <span class="keyword">public</span> <em class="replaceable"><code><a class="link" href="integral_constant.html" title="integral_constant">true_type</a>-or-<a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code></em> <span class="special">{};</span> +</pre> +<p> + <span class="bold"><strong>Inherits:</strong></span> If T is a (possibly cv-qualified) + polymorphic type then inherits from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>, + otherwise inherits from <a class="link" href="integral_constant.html" title="integral_constant">false_type</a>. + Type <code class="computeroutput"><span class="identifier">T</span></code> must be a complete + type. + </p> +<p> + <span class="bold"><strong>C++ Standard Reference:</strong></span> 10.3. + </p> +<p> + <span class="bold"><strong>Compiler Compatibility:</strong></span> The implementation + requires some knowledge of the compilers ABI, it does actually seem to work + with the majority of compilers though. + </p> +<p> + <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"> <span class="preprocessor">#include</span> + <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">is_polymorphic</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + </p> +<p> + <span class="bold"><strong>Examples:</strong></span> + </p> +<div class="blockquote"><blockquote class="blockquote"><p> + Given: <code class="computeroutput"><span class="keyword">class</span> <span class="identifier">poly</span><span class="special">{</span> <span class="keyword">virtual</span> <span class="special">~</span><span class="identifier">poly</span><span class="special">();</span> <span class="special">};</span></code> + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_polymorphic</span><span class="special"><</span><span class="identifier">poly</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_polymorphic</span><span class="special"><</span><span class="identifier">poly</span> <span class="keyword">const</span><span class="special">>::</span><span class="identifier">type</span></code> + is the type <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_polymorphic</span><span class="special"><</span><span class="identifier">poly</span><span class="special">>::</span><span class="identifier">value</span></code> is an integral constant expression + that evaluates to <span class="emphasis"><em>true</em></span>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_polymorphic</span><span class="special"><</span><span class="identifier">T</span><span class="special">>::</span><span class="identifier">value_type</span></code> is the type <code class="computeroutput"><span class="keyword">bool</span></code>. + </p></blockquote></div> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="is_pointer.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="is_reference.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/reference/is_reference.html b/libs/type_traits/doc/html/boost_typetraits/reference/is_reference.html new file mode 100644 index 0000000000..25ea7967c4 --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/reference/is_reference.html @@ -0,0 +1,92 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>is_reference</title> +<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../reference.html" title="Alphabetical Reference"> +<link rel="prev" href="is_polymorphic.html" title="is_polymorphic"> +<link rel="next" href="is_rvalue_reference.html" title="is_rvalue_reference"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td> +<td align="center"><a href="../../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="is_polymorphic.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="is_rvalue_reference.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h3 class="title"> +<a name="boost_typetraits.reference.is_reference"></a><a class="link" href="is_reference.html" title="is_reference">is_reference</a> +</h3></div></div></div> +<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">is_reference</span> <span class="special">:</span> <span class="keyword">public</span> <em class="replaceable"><code><a class="link" href="integral_constant.html" title="integral_constant">true_type</a>-or-<a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code></em> <span class="special">{};</span> +</pre> +<p> + <span class="bold"><strong>Inherits:</strong></span> If T is a reference type (either + an lvalue reference or an rvalue reference) then inherits from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>, + otherwise inherits from <a class="link" href="integral_constant.html" title="integral_constant">false_type</a>. + </p> +<p> + <span class="bold"><strong>C++ Standard Reference:</strong></span> 3.9.2 and 8.3.2. + </p> +<p> + <span class="bold"><strong>Compiler Compatibility:</strong></span> 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. + </p> +<p> + <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"> <span class="preprocessor">#include</span> + <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">is_reference</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + </p> +<p> + <span class="bold"><strong>Examples:</strong></span> + </p> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_reference</span><span class="special"><</span><span class="keyword">int</span><span class="special">&></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_reference</span><span class="special"><</span><span class="keyword">int</span> <span class="keyword">const</span><span class="special">&>::</span><span class="identifier">type</span></code> + is the type <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_reference</span><span class="special"><</span><span class="keyword">int</span> <span class="keyword">const</span><span class="special">&&>::</span><span class="identifier">type</span></code> + is the type <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_reference</span><span class="special"><</span><span class="keyword">int</span> <span class="special">(&)(</span><span class="keyword">long</span><span class="special">)>::</span><span class="identifier">value</span></code> is an integral constant expression + that evaluates to <span class="emphasis"><em>true</em></span> (the argument in this case + is a reference to a function). + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_reference</span><span class="special"><</span><span class="identifier">T</span><span class="special">>::</span><span class="identifier">value_type</span></code> is the type <code class="computeroutput"><span class="keyword">bool</span></code>. + </p></blockquote></div> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="is_polymorphic.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="is_rvalue_reference.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/reference/is_rvalue_reference.html b/libs/type_traits/doc/html/boost_typetraits/reference/is_rvalue_reference.html new file mode 100644 index 0000000000..d193b1e242 --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/reference/is_rvalue_reference.html @@ -0,0 +1,92 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>is_rvalue_reference</title> +<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../reference.html" title="Alphabetical Reference"> +<link rel="prev" href="is_reference.html" title="is_reference"> +<link rel="next" href="is_same.html" title="is_same"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td> +<td align="center"><a href="../../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="is_reference.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="is_same.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h3 class="title"> +<a name="boost_typetraits.reference.is_rvalue_reference"></a><a class="link" href="is_rvalue_reference.html" title="is_rvalue_reference">is_rvalue_reference</a> +</h3></div></div></div> +<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">is_rvalue_reference</span> <span class="special">:</span> <span class="keyword">public</span> <em class="replaceable"><code><a class="link" href="integral_constant.html" title="integral_constant">true_type</a>-or-<a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code></em> <span class="special">{};</span> +</pre> +<p> + <span class="bold"><strong>Inherits:</strong></span> If T is an rvalue reference type + then inherits from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>, + otherwise inherits from <a class="link" href="integral_constant.html" title="integral_constant">false_type</a>. + </p> +<p> + <span class="bold"><strong>C++ Standard Reference:</strong></span> 3.9.2 and 8.3.2. + </p> +<p> + <span class="bold"><strong>Compiler Compatibility:</strong></span> 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. + </p> +<p> + <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"> <span class="preprocessor">#include</span> + <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">is_rvalue_reference</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + </p> +<p> + <span class="bold"><strong>Examples:</strong></span> + </p> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_rvalue_reference</span><span class="special"><</span><span class="keyword">int</span><span class="special">&&></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_rvalue_reference</span><span class="special"><</span><span class="keyword">int</span> <span class="keyword">const</span><span class="special">&&>::</span><span class="identifier">type</span></code> + is the type <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_rvalue_reference</span><span class="special"><</span><span class="keyword">int</span> <span class="keyword">const</span><span class="special">&>::</span><span class="identifier">type</span></code> + is the type <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_rvalue_reference</span><span class="special"><</span><span class="keyword">int</span> <span class="special">(&&)(</span><span class="keyword">long</span><span class="special">)>::</span><span class="identifier">value</span></code> is an integral constant expression + that evaluates to <span class="emphasis"><em>true</em></span> (the argument in this case + is an rvalue reference to a function). + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_rvalue_reference</span><span class="special"><</span><span class="identifier">T</span><span class="special">>::</span><span class="identifier">value_type</span></code> is the type <code class="computeroutput"><span class="keyword">bool</span></code>. + </p></blockquote></div> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="is_reference.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="is_same.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/reference/is_same.html b/libs/type_traits/doc/html/boost_typetraits/reference/is_same.html new file mode 100644 index 0000000000..99a445f8dc --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/reference/is_same.html @@ -0,0 +1,91 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>is_same</title> +<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../reference.html" title="Alphabetical Reference"> +<link rel="prev" href="is_rvalue_reference.html" title="is_rvalue_reference"> +<link rel="next" href="is_scalar.html" title="is_scalar"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td> +<td align="center"><a href="../../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="is_rvalue_reference.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="is_scalar.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h3 class="title"> +<a name="boost_typetraits.reference.is_same"></a><a class="link" href="is_same.html" title="is_same">is_same</a> +</h3></div></div></div> +<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">U</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">is_same</span> <span class="special">:</span> <span class="keyword">public</span> <em class="replaceable"><code><a class="link" href="integral_constant.html" title="integral_constant">true_type</a>-or-<a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code></em> <span class="special">{};</span> +</pre> +<p> + <span class="bold"><strong>Inherits:</strong></span> If T and U are the same types + then inherits from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>, + otherwise inherits from <a class="link" href="integral_constant.html" title="integral_constant">false_type</a>. + </p> +<p> + <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"> <span class="preprocessor">#include</span> + <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">is_same</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + </p> +<p> + <span class="bold"><strong>Compiler Compatibility:</strong></span> If the compiler + does not support partial-specialization of class templates, then this template + can not be used with abstract, incomplete or function types. + </p> +<p> + <span class="bold"><strong>Examples:</strong></span> + </p> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_same</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_same</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">>::</span><span class="identifier">type</span></code> + is the type <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_same</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">>::</span><span class="identifier">value</span></code> + is an integral constant expression that evaluates to <span class="emphasis"><em>true</em></span>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_same</span><span class="special"><</span><span class="keyword">int</span> <span class="keyword">const</span><span class="special">,</span> <span class="keyword">int</span><span class="special">>::</span><span class="identifier">value</span></code> is an integral constant expression + that evaluates to <span class="emphasis"><em>false</em></span>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_same</span><span class="special"><</span><span class="keyword">int</span><span class="special">&,</span> <span class="keyword">int</span><span class="special">>::</span><span class="identifier">value</span></code> is an integral constant expression + that evaluates to <span class="emphasis"><em>false</em></span>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_same</span><span class="special"><</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">T</span><span class="special">>::</span><span class="identifier">value_type</span></code> + is the type <code class="computeroutput"><span class="keyword">bool</span></code>. + </p></blockquote></div> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="is_rvalue_reference.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="is_scalar.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/reference/is_scalar.html b/libs/type_traits/doc/html/boost_typetraits/reference/is_scalar.html new file mode 100644 index 0000000000..812a3fb492 --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/reference/is_scalar.html @@ -0,0 +1,99 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>is_scalar</title> +<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../reference.html" title="Alphabetical Reference"> +<link rel="prev" href="is_same.html" title="is_same"> +<link rel="next" href="is_signed.html" title="is_signed"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td> +<td align="center"><a href="../../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="is_same.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="is_signed.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h3 class="title"> +<a name="boost_typetraits.reference.is_scalar"></a><a class="link" href="is_scalar.html" title="is_scalar">is_scalar</a> +</h3></div></div></div> +<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">is_scalar</span> <span class="special">:</span> <span class="keyword">public</span> <em class="replaceable"><code><a class="link" href="integral_constant.html" title="integral_constant">true_type</a>-or-<a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code></em> <span class="special">{};</span> +</pre> +<p> + <span class="bold"><strong>Inherits:</strong></span> If T is a (possibly cv-qualified) + scalar type then inherits from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>, + otherwise inherits from <a class="link" href="integral_constant.html" title="integral_constant">false_type</a>. + Scalar types include integral, floating point, enumeration, pointer, and + pointer-to-member types. + </p> +<p> + <span class="bold"><strong>C++ Standard Reference:</strong></span> 3.9p10. + </p> +<p> + <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"> <span class="preprocessor">#include</span> + <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">is_scalar</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + </p> +<p> + <span class="bold"><strong>Compiler Compatibility:</strong></span> If the compiler + does not support partial-specialization of class templates, then this template + can not be used with function types. + </p> +<p> + <span class="bold"><strong>Examples:</strong></span> + </p> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_scalar</span><span class="special"><</span><span class="keyword">int</span><span class="special">*></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_scalar</span><span class="special"><</span><span class="keyword">int</span><span class="special">>::</span><span class="identifier">type</span></code> is the type <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_scalar</span><span class="special"><</span><span class="keyword">double</span><span class="special">>::</span><span class="identifier">value</span></code> is an integral constant expression + that evaluates to <span class="emphasis"><em>true</em></span>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_scalar</span><span class="special"><</span><span class="keyword">int</span> <span class="special">(*)(</span><span class="keyword">long</span><span class="special">)>::</span><span class="identifier">value</span></code> is an integral constant expression + that evaluates to <span class="emphasis"><em>true</em></span>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_scalar</span><span class="special"><</span><span class="keyword">int</span> <span class="special">(</span><span class="identifier">MyClass</span><span class="special">::*)(</span><span class="keyword">long</span><span class="special">)>::</span><span class="identifier">value</span></code> + is an integral constant expression that evaluates to <span class="emphasis"><em>true</em></span>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_scalar</span><span class="special"><</span><span class="keyword">int</span> <span class="special">(</span><span class="identifier">MyClass</span><span class="special">::*)>::</span><span class="identifier">value</span></code> + is an integral constant expression that evaluates to <span class="emphasis"><em>true</em></span>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_scalar</span><span class="special"><</span><span class="identifier">T</span><span class="special">>::</span><span class="identifier">value_type</span></code> is the type <code class="computeroutput"><span class="keyword">bool</span></code>. + </p></blockquote></div> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="is_same.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="is_signed.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/reference/is_signed.html b/libs/type_traits/doc/html/boost_typetraits/reference/is_signed.html new file mode 100644 index 0000000000..e51ac73bee --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/reference/is_signed.html @@ -0,0 +1,93 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>is_signed</title> +<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../reference.html" title="Alphabetical Reference"> +<link rel="prev" href="is_scalar.html" title="is_scalar"> +<link rel="next" href="is_stateless.html" title="is_stateless"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td> +<td align="center"><a href="../../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="is_scalar.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="is_stateless.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h3 class="title"> +<a name="boost_typetraits.reference.is_signed"></a><a class="link" href="is_signed.html" title="is_signed">is_signed</a> +</h3></div></div></div> +<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">is_signed</span> <span class="special">:</span> <span class="keyword">public</span> <em class="replaceable"><code><a class="link" href="integral_constant.html" title="integral_constant">true_type</a>-or-<a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code></em> <span class="special">{};</span> +</pre> +<p> + <span class="bold"><strong>Inherits:</strong></span> If T is an signed integer type + or an enumerated type with an underlying signed integer type, then inherits + from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>, + otherwise inherits from <a class="link" href="integral_constant.html" title="integral_constant">false_type</a>. + </p> +<p> + <span class="bold"><strong>C++ Standard Reference:</strong></span> 3.9.1, 7.2. + </p> +<p> + <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"> <span class="preprocessor">#include</span> + <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">is_signed</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + </p> +<p> + <span class="bold"><strong>Examples:</strong></span> + </p> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_signed</span><span class="special"><</span><span class="keyword">int</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_signed</span><span class="special"><</span><span class="keyword">int</span> <span class="keyword">const</span> <span class="keyword">volatile</span><span class="special">>::</span><span class="identifier">type</span></code> is the type <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_signed</span><span class="special"><</span><span class="keyword">unsigned</span> <span class="keyword">int</span><span class="special">>::</span><span class="identifier">value</span></code> + is an integral constant expression that evaluates to <span class="emphasis"><em>false</em></span>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_signed</span><span class="special"><</span><span class="identifier">myclass</span><span class="special">>::</span><span class="identifier">value</span></code> is an integral constant expression + that evaluates to <span class="emphasis"><em>false</em></span>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_signed</span><span class="special"><</span><span class="keyword">char</span><span class="special">>::</span><span class="identifier">value</span></code> is an integral constant expression + whose value depends upon the signedness of type <code class="computeroutput"><span class="keyword">char</span></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_signed</span><span class="special"><</span><span class="keyword">long</span> <span class="keyword">long</span><span class="special">>::</span><span class="identifier">value</span></code> + is an integral constant expression that evaluates to <span class="emphasis"><em>true</em></span>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_signed</span><span class="special"><</span><span class="identifier">T</span><span class="special">>::</span><span class="identifier">value_type</span></code> is the type <code class="computeroutput"><span class="keyword">bool</span></code>. + </p></blockquote></div> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="is_scalar.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="is_stateless.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/reference/is_stateless.html b/libs/type_traits/doc/html/boost_typetraits/reference/is_stateless.html new file mode 100644 index 0000000000..7f6fd2a5d7 --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/reference/is_stateless.html @@ -0,0 +1,91 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>is_stateless</title> +<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../reference.html" title="Alphabetical Reference"> +<link rel="prev" href="is_signed.html" title="is_signed"> +<link rel="next" href="is_union.html" title="is_union"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td> +<td align="center"><a href="../../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="is_signed.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="is_union.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h3 class="title"> +<a name="boost_typetraits.reference.is_stateless"></a><a class="link" href="is_stateless.html" title="is_stateless">is_stateless</a> +</h3></div></div></div> +<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">is_stateless</span> <span class="special">:</span> <span class="keyword">public</span> <em class="replaceable"><code><a class="link" href="integral_constant.html" title="integral_constant">true_type</a>-or-<a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code></em> <span class="special">{};</span> +</pre> +<p> + <span class="bold"><strong>Inherits:</strong></span> If T is a stateless type then + inherits from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>, + otherwise from <a class="link" href="integral_constant.html" title="integral_constant">false_type</a>. + </p> +<p> + Type T must be a complete type. + </p> +<p> + A stateless type is a type that has no storage and whose constructors and + destructors are trivial. That means that <code class="computeroutput"><span class="identifier">is_stateless</span></code> + only inherits from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a> + if the following expression is <code class="computeroutput"><span class="keyword">true</span></code>: + </p> +<pre class="programlisting"><span class="special">::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_trivial_constructor</span><span class="special"><</span><span class="identifier">T</span><span class="special">>::</span><span class="identifier">value</span> +<span class="special">&&</span> <span class="special">::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_trivial_copy</span><span class="special"><</span><span class="identifier">T</span><span class="special">>::</span><span class="identifier">value</span> +<span class="special">&&</span> <span class="special">::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_trivial_destructor</span><span class="special"><</span><span class="identifier">T</span><span class="special">>::</span><span class="identifier">value</span> +<span class="special">&&</span> <span class="special">::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">is_class</span><span class="special"><</span><span class="identifier">T</span><span class="special">>::</span><span class="identifier">value</span> +<span class="special">&&</span> <span class="special">::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">is_empty</span><span class="special"><</span><span class="identifier">T</span><span class="special">>::</span><span class="identifier">value</span> +</pre> +<p> + <span class="bold"><strong>C++ Standard Reference:</strong></span> 3.9p10. + </p> +<p> + <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"> <span class="preprocessor">#include</span> + <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">is_stateless</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + </p> +<p> + <span class="bold"><strong>Compiler Compatibility:</strong></span> If the compiler + does not support partial-specialization of class templates, then this template + can not be used with function types. + </p> +<p> + 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 2011) compilers more recent than Visual + C++ 8, GCC-4.3, Greenhills 6.0, Intel-11.0, and Codegear have the necessary + compiler <a class="link" href="../intrinsics.html" title="Support for Compiler Intrinsics">intrinsics</a> to + ensure that this trait "just works". + </p> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="is_signed.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="is_union.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/reference/is_union.html b/libs/type_traits/doc/html/boost_typetraits/reference/is_union.html new file mode 100644 index 0000000000..29a73f6f77 --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/reference/is_union.html @@ -0,0 +1,106 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>is_union</title> +<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../reference.html" title="Alphabetical Reference"> +<link rel="prev" href="is_stateless.html" title="is_stateless"> +<link rel="next" href="is_unsigned.html" title="is_unsigned"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td> +<td align="center"><a href="../../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="is_stateless.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="is_unsigned.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h3 class="title"> +<a name="boost_typetraits.reference.is_union"></a><a class="link" href="is_union.html" title="is_union">is_union</a> +</h3></div></div></div> +<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">is_union</span> <span class="special">:</span> <span class="keyword">public</span> <em class="replaceable"><code><a class="link" href="integral_constant.html" title="integral_constant">true_type</a>-or-<a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code></em> <span class="special">{};</span> +</pre> +<p> + <span class="bold"><strong>Inherits:</strong></span> If T is a (possibly cv-qualified) + union type then inherits from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>, + otherwise inherits from <a class="link" href="integral_constant.html" title="integral_constant">false_type</a>. + Currently requires some kind of compiler support, otherwise unions are identified + as classes. + </p> +<p> + <span class="bold"><strong>C++ Standard Reference:</strong></span> 3.9.2 and 9.5. + </p> +<p> + <span class="bold"><strong>Compiler Compatibility:</strong></span> 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 <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>, + 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 2011) compilers more recent + than Visual C++ 8, GCC-4.3, Greenhills 6.0, Intel-11.0, and Codegear have + the necessary compiler <a class="link" href="../intrinsics.html" title="Support for Compiler Intrinsics">intrinsics</a> + to ensure that this trait "just works". You may also test to see + if the necessary <a class="link" href="../intrinsics.html" title="Support for Compiler Intrinsics">intrinsics</a> + are available by checking to see if the macro <code class="computeroutput"><span class="identifier">BOOST_IS_UNION</span></code> + is defined. + </p> +<p> + <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"> <span class="preprocessor">#include</span> + <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">is_union</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + </p> +<p> + <span class="bold"><strong>Examples:</strong></span> + </p> +<p> + Given <code class="computeroutput"><span class="keyword">union</span> <span class="identifier">my_union</span> + <span class="special">{};</span></code> then: + </p> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_union</span><span class="special"><</span><span class="identifier">my_union</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_union</span><span class="special"><</span><span class="keyword">const</span> <span class="identifier">my_union</span><span class="special">>::</span><span class="identifier">type</span></code> + is the type <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_union</span><span class="special"><</span><span class="identifier">my_union</span><span class="special">>::</span><span class="identifier">value</span></code> is an integral constant expression + that evaluates to <span class="emphasis"><em>true</em></span>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_union</span><span class="special"><</span><span class="identifier">my_union</span><span class="special">*>::</span><span class="identifier">value</span></code> is an integral constant expression + that evaluates to <span class="emphasis"><em>false</em></span>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_union</span><span class="special"><</span><span class="identifier">T</span><span class="special">>::</span><span class="identifier">value_type</span></code> is the type <code class="computeroutput"><span class="keyword">bool</span></code>. + </p></blockquote></div> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="is_stateless.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="is_unsigned.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/reference/is_unsigned.html b/libs/type_traits/doc/html/boost_typetraits/reference/is_unsigned.html new file mode 100644 index 0000000000..56b511af95 --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/reference/is_unsigned.html @@ -0,0 +1,94 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>is_unsigned</title> +<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../reference.html" title="Alphabetical Reference"> +<link rel="prev" href="is_union.html" title="is_union"> +<link rel="next" href="is_virtual_base_of.html" title="is_virtual_base_of"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td> +<td align="center"><a href="../../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="is_union.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="is_virtual_base_of.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h3 class="title"> +<a name="boost_typetraits.reference.is_unsigned"></a><a class="link" href="is_unsigned.html" title="is_unsigned">is_unsigned</a> +</h3></div></div></div> +<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">is_unsigned</span> <span class="special">:</span> <span class="keyword">public</span> <em class="replaceable"><code><a class="link" href="integral_constant.html" title="integral_constant">true_type</a>-or-<a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code></em> <span class="special">{};</span> +</pre> +<p> + <span class="bold"><strong>Inherits:</strong></span> If T is an unsigned integer type + or an enumerated type with an underlying unsigned integer type, then inherits + from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>, + otherwise inherits from <a class="link" href="integral_constant.html" title="integral_constant">false_type</a>. + </p> +<p> + <span class="bold"><strong>C++ Standard Reference:</strong></span> 3.9.1, 7.2. + </p> +<p> + <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"> <span class="preprocessor">#include</span> + <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">is_unsigned</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + </p> +<p> + <span class="bold"><strong>Examples:</strong></span> + </p> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_unsigned</span><span class="special"><</span><span class="keyword">unsigned</span> <span class="keyword">int</span><span class="special">></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_unsigned</span><span class="special"><</span><span class="keyword">unsigned</span> <span class="keyword">int</span> <span class="keyword">const</span> <span class="keyword">volatile</span><span class="special">>::</span><span class="identifier">type</span></code> + is the type <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_unsigned</span><span class="special"><</span><span class="keyword">int</span><span class="special">>::</span><span class="identifier">value</span></code> is an integral constant expression + that evaluates to <span class="emphasis"><em>false</em></span>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_unsigned</span><span class="special"><</span><span class="identifier">myclass</span><span class="special">>::</span><span class="identifier">value</span></code> is an integral constant expression + that evaluates to <span class="emphasis"><em>false</em></span>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_unsigned</span><span class="special"><</span><span class="keyword">char</span><span class="special">>::</span><span class="identifier">value</span></code> is an integral constant expression + whose value depends upon the signedness of type <code class="computeroutput"><span class="keyword">char</span></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_unsigned</span><span class="special"><</span><span class="keyword">unsigned</span> <span class="keyword">long</span> + <span class="keyword">long</span><span class="special">>::</span><span class="identifier">value</span></code> is an integral constant expression + that evaluates to <span class="emphasis"><em>true</em></span>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_unsigned</span><span class="special"><</span><span class="identifier">T</span><span class="special">>::</span><span class="identifier">value_type</span></code> is the type <code class="computeroutput"><span class="keyword">bool</span></code>. + </p></blockquote></div> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="is_union.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="is_virtual_base_of.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/reference/is_virtual_base_of.html b/libs/type_traits/doc/html/boost_typetraits/reference/is_virtual_base_of.html new file mode 100644 index 0000000000..e3ab27dc5d --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/reference/is_virtual_base_of.html @@ -0,0 +1,117 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>is_virtual_base_of</title> +<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../reference.html" title="Alphabetical Reference"> +<link rel="prev" href="is_unsigned.html" title="is_unsigned"> +<link rel="next" href="is_void.html" title="is_void"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td> +<td align="center"><a href="../../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="is_unsigned.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="is_void.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h3 class="title"> +<a name="boost_typetraits.reference.is_virtual_base_of"></a><a class="link" href="is_virtual_base_of.html" title="is_virtual_base_of">is_virtual_base_of</a> +</h3></div></div></div> +<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">Base</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Derived</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">is_virtual_base_of</span> <span class="special">:</span> <span class="keyword">public</span> <em class="replaceable"><code><a class="link" href="integral_constant.html" title="integral_constant">true_type</a>-or-<a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code></em> <span class="special">{};</span> +</pre> +<p> + <span class="bold"><strong>Inherits:</strong></span> If Base is a virtual base class + of type Derived then inherits from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>, + otherwise inherits from <a class="link" href="integral_constant.html" title="integral_constant">false_type</a>. + </p> +<p> + Types <code class="computeroutput"><span class="identifier">Base</span></code> and <code class="computeroutput"><span class="identifier">Derived</span></code> must not be incomplete types. + </p> +<p> + <span class="bold"><strong>C++ Standard Reference:</strong></span> 10. + </p> +<p> + <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"> <span class="preprocessor">#include</span> + <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">is_virtual_base_of</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + </p> +<p> + <span class="bold"><strong>Compiler Compatibility:</strong></span> this trait also + requires a working <a class="link" href="is_base_of.html" title="is_base_of">is_base_of</a> + trait. + </p> +<div class="note"><table border="0" summary="Note"> +<tr> +<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../../doc/src/images/note.png"></td> +<th align="left">Note</th> +</tr> +<tr><td align="left" valign="top"><p> + There are a small number of cases where it's simply not possible for this + trait to work, and where attempting to instantiate the trait will cause + compiler errors (see bug report <a href="https://svn.boost.org/trac/boost/ticket/3730" target="_top">#3730</a>). + Further more the issues may well be compiler specific. In this situation + the user should supply a full specialization of the trait to work around + the problem. + </p></td></tr> +</table></div> +<p> + <span class="bold"><strong>Examples:</strong></span> + </p> +<div class="blockquote"><blockquote class="blockquote"><p> + Given: <code class="computeroutput"> <span class="keyword">class</span> <span class="identifier">Base</span><span class="special">{};</span> <span class="keyword">class</span> <span class="identifier">Derived</span> <span class="special">:</span> <span class="keyword">public</span> <span class="keyword">virtual</span> + <span class="identifier">Base</span><span class="special">{};</span></code> + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_virtual_base_of</span><span class="special"><</span><span class="identifier">Base</span><span class="special">,</span> <span class="identifier">Derived</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_virtual_base_of</span><span class="special"><</span><span class="identifier">Base</span><span class="special">,</span> <span class="identifier">Derived</span><span class="special">>::</span><span class="identifier">type</span></code> is the type <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_virtual_base_of</span><span class="special"><</span><span class="identifier">Base</span><span class="special">,</span> <span class="identifier">Derived</span><span class="special">>::</span><span class="identifier">value</span></code> is an integral constant expression + that evaluates to <span class="emphasis"><em>true</em></span>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_virtual_base_of</span><span class="special"><</span><span class="identifier">SomeClassType</span><span class="special">,</span> + <span class="identifier">SomeClassType</span><span class="special">>::</span><span class="identifier">value</span></code> is an integral constant expression + that evaluates to <span class="emphasis"><em>true</em></span>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_virtual_base_of</span><span class="special"><</span><span class="identifier">NotAClassType</span><span class="special">,</span> + <span class="identifier">NotAClassType</span><span class="special">>::</span><span class="identifier">value</span></code> is an integral constant expression + that evaluates to <span class="emphasis"><em>false</em></span>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_virtual_base_of</span><span class="special"><</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">U</span><span class="special">>::</span><span class="identifier">value_type</span></code> + is the type <code class="computeroutput"><span class="keyword">bool</span></code>. + </p></blockquote></div> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="is_unsigned.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="is_void.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/reference/is_void.html b/libs/type_traits/doc/html/boost_typetraits/reference/is_void.html new file mode 100644 index 0000000000..425582b39d --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/reference/is_void.html @@ -0,0 +1,85 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>is_void</title> +<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../reference.html" title="Alphabetical Reference"> +<link rel="prev" href="is_virtual_base_of.html" title="is_virtual_base_of"> +<link rel="next" href="is_volatile.html" title="is_volatile"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td> +<td align="center"><a href="../../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="is_virtual_base_of.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="is_volatile.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h3 class="title"> +<a name="boost_typetraits.reference.is_void"></a><a class="link" href="is_void.html" title="is_void">is_void</a> +</h3></div></div></div> +<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">is_void</span> <span class="special">:</span> <span class="keyword">public</span> <em class="replaceable"><code><a class="link" href="integral_constant.html" title="integral_constant">true_type</a>-or-<a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code></em> <span class="special">{};</span> +</pre> +<p> + <span class="bold"><strong>Inherits:</strong></span> If T is a (possibly cv-qualified) + void type then inherits from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>, + otherwise inherits from <a class="link" href="integral_constant.html" title="integral_constant">false_type</a>. + </p> +<p> + <span class="bold"><strong>C++ Standard Reference:</strong></span> 3.9.1p9. + </p> +<p> + <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"> <span class="preprocessor">#include</span> + <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">is_void</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + </p> +<p> + <span class="bold"><strong>Examples:</strong></span> + </p> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_void</span><span class="special"><</span><span class="keyword">void</span><span class="special">></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_void</span><span class="special"><</span><span class="keyword">const</span> <span class="keyword">void</span><span class="special">>::</span><span class="identifier">type</span></code> + is the type <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_void</span><span class="special"><</span><span class="keyword">void</span><span class="special">>::</span><span class="identifier">value</span></code> is an integral constant expression + that evaluates to <span class="emphasis"><em>true</em></span>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_void</span><span class="special"><</span><span class="keyword">void</span><span class="special">*>::</span><span class="identifier">value</span></code> is an integral constant expression + that evaluates to <span class="emphasis"><em>false</em></span>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_void</span><span class="special"><</span><span class="identifier">T</span><span class="special">>::</span><span class="identifier">value_type</span></code> is the type <code class="computeroutput"><span class="keyword">bool</span></code>. + </p></blockquote></div> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="is_virtual_base_of.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="is_volatile.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/reference/is_volatile.html b/libs/type_traits/doc/html/boost_typetraits/reference/is_volatile.html new file mode 100644 index 0000000000..59083ba258 --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/reference/is_volatile.html @@ -0,0 +1,85 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>is_volatile</title> +<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../reference.html" title="Alphabetical Reference"> +<link rel="prev" href="is_void.html" title="is_void"> +<link rel="next" href="make_signed.html" title="make_signed"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td> +<td align="center"><a href="../../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="is_void.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="make_signed.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h3 class="title"> +<a name="boost_typetraits.reference.is_volatile"></a><a class="link" href="is_volatile.html" title="is_volatile">is_volatile</a> +</h3></div></div></div> +<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">is_volatile</span> <span class="special">:</span> <span class="keyword">public</span> <em class="replaceable"><code><a class="link" href="integral_constant.html" title="integral_constant">true_type</a>-or-<a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code></em> <span class="special">{};</span> +</pre> +<p> + <span class="bold"><strong>Inherits:</strong></span> If T is a (top level) volatile-qualified + type then inherits from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>, + otherwise inherits from <a class="link" href="integral_constant.html" title="integral_constant">false_type</a>. + </p> +<p> + <span class="bold"><strong>C++ Standard Reference:</strong></span> 3.9.3. + </p> +<p> + <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"> <span class="preprocessor">#include</span> + <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">is_volatile</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + </p> +<p> + <span class="bold"><strong>Examples:</strong></span> + </p> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_volatile</span><span class="special"><</span><span class="keyword">volatile</span> <span class="keyword">int</span><span class="special">></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_volatile</span><span class="special"><</span><span class="keyword">const</span> <span class="keyword">volatile</span> + <span class="keyword">int</span><span class="special">>::</span><span class="identifier">type</span></code> is the type <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_volatile</span><span class="special"><</span><span class="keyword">int</span><span class="special">*</span> <span class="keyword">volatile</span><span class="special">>::</span><span class="identifier">value</span></code> + is an integral constant expression that evaluates to <span class="emphasis"><em>true</em></span>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_volatile</span><span class="special"><</span><span class="keyword">int</span> <span class="keyword">volatile</span><span class="special">*>::</span><span class="identifier">value</span></code> + is an integral constant expression that evaluates to <span class="emphasis"><em>false</em></span>: + the volatile qualifier is not at the top level in this case. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">is_volatile</span><span class="special"><</span><span class="identifier">T</span><span class="special">>::</span><span class="identifier">value_type</span></code> is the type <code class="computeroutput"><span class="keyword">bool</span></code>. + </p></blockquote></div> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="is_void.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="make_signed.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/reference/make_signed.html b/libs/type_traits/doc/html/boost_typetraits/reference/make_signed.html new file mode 100644 index 0000000000..fc3af4bdd3 --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/reference/make_signed.html @@ -0,0 +1,161 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>make_signed</title> +<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../reference.html" title="Alphabetical Reference"> +<link rel="prev" href="is_volatile.html" title="is_volatile"> +<link rel="next" href="make_unsigned.html" title="make_unsigned"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td> +<td align="center"><a href="../../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="is_volatile.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="make_unsigned.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h3 class="title"> +<a name="boost_typetraits.reference.make_signed"></a><a class="link" href="make_signed.html" title="make_signed">make_signed</a> +</h3></div></div></div> +<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">make_signed</span> +<span class="special">{</span> + <span class="keyword">typedef</span> <em class="replaceable"><code>see-below</code></em> <span class="identifier">type</span><span class="special">;</span> +<span class="special">};</span> +</pre> +<p> + <span class="bold"><strong>type:</strong></span> 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. + </p> +<p> + If T has any cv-qualifiers then these are also present on the result type. + </p> +<p> + <span class="bold"><strong>Requires:</strong></span> T must be an integer or enumerated + type, and must not be the type bool. + </p> +<p> + <span class="bold"><strong>C++ Standard Reference:</strong></span> 3.9.1. + </p> +<p> + <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"> <span class="preprocessor">#include</span> + <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">make_signed</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + </p> +<div class="table"> +<a name="boost_typetraits.reference.make_signed.examples"></a><p class="title"><b>Table 1.22. Examples</b></p> +<div class="table-contents"><table class="table" summary="Examples"> +<colgroup> +<col> +<col> +</colgroup> +<thead><tr> +<th> + <p> + Expression + </p> + </th> +<th> + <p> + Result Type + </p> + </th> +</tr></thead> +<tbody> +<tr> +<td> + <p> + <code class="computeroutput"><span class="identifier">make_signed</span><span class="special"><</span><span class="keyword">int</span><span class="special">>::</span><span class="identifier">type</span></code> + </p> + </td> +<td> + <p> + <code class="computeroutput"><span class="keyword">int</span></code> + </p> + </td> +</tr> +<tr> +<td> + <p> + <code class="computeroutput"><span class="identifier">make_signed</span><span class="special"><</span><span class="keyword">unsigned</span> <span class="keyword">int</span> + <span class="keyword">const</span><span class="special">>::</span><span class="identifier">type</span></code> + </p> + </td> +<td> + <p> + <code class="computeroutput"><span class="keyword">int</span> <span class="keyword">const</span></code> + </p> + </td> +</tr> +<tr> +<td> + <p> + <code class="computeroutput"><span class="identifier">make_signed</span><span class="special"><</span><span class="keyword">const</span> <span class="keyword">unsigned</span> + <span class="keyword">long</span> <span class="keyword">long</span><span class="special">>::</span><span class="identifier">type</span></code> + </p> + </td> +<td> + <p> + <code class="computeroutput"><span class="keyword">const</span> <span class="keyword">long</span> + <span class="keyword">long</span></code> + </p> + </td> +</tr> +<tr> +<td> + <p> + <code class="computeroutput"><span class="identifier">make_signed</span><span class="special"><</span><span class="identifier">my_enum</span><span class="special">>::</span><span class="identifier">type</span></code> + </p> + </td> +<td> + <p> + A signed integer type with the same width as the enum. + </p> + </td> +</tr> +<tr> +<td> + <p> + <code class="computeroutput"><span class="identifier">make_signed</span><span class="special"><</span><span class="keyword">wchar_t</span><span class="special">>::</span><span class="identifier">type</span></code> + </p> + </td> +<td> + <p> + A signed integer type with the same width as wchar_t. + </p> + </td> +</tr> +</tbody> +</table></div> +</div> +<br class="table-break"> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="is_volatile.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="make_unsigned.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/reference/make_unsigned.html b/libs/type_traits/doc/html/boost_typetraits/reference/make_unsigned.html new file mode 100644 index 0000000000..7e5af9cebd --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/reference/make_unsigned.html @@ -0,0 +1,162 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>make_unsigned</title> +<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../reference.html" title="Alphabetical Reference"> +<link rel="prev" href="make_signed.html" title="make_signed"> +<link rel="next" href="promote.html" title="promote"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td> +<td align="center"><a href="../../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="make_signed.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="promote.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h3 class="title"> +<a name="boost_typetraits.reference.make_unsigned"></a><a class="link" href="make_unsigned.html" title="make_unsigned">make_unsigned</a> +</h3></div></div></div> +<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">make_unsigned</span> +<span class="special">{</span> + <span class="keyword">typedef</span> <em class="replaceable"><code>see-below</code></em> <span class="identifier">type</span><span class="special">;</span> +<span class="special">};</span> +</pre> +<p> + <span class="bold"><strong>type:</strong></span> 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. + </p> +<p> + If T has any cv-qualifiers then these are also present on the result type. + </p> +<p> + <span class="bold"><strong>Requires:</strong></span> T must be an integer or enumerated + type, and must not be the type bool. + </p> +<p> + <span class="bold"><strong>C++ Standard Reference:</strong></span> 3.9.1. + </p> +<p> + <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"> <span class="preprocessor">#include</span> + <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">make_unsigned</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + </p> +<div class="table"> +<a name="boost_typetraits.reference.make_unsigned.examples"></a><p class="title"><b>Table 1.23. Examples</b></p> +<div class="table-contents"><table class="table" summary="Examples"> +<colgroup> +<col> +<col> +</colgroup> +<thead><tr> +<th> + <p> + Expression + </p> + </th> +<th> + <p> + Result Type + </p> + </th> +</tr></thead> +<tbody> +<tr> +<td> + <p> + <code class="computeroutput"><span class="identifier">make_unsigned</span><span class="special"><</span><span class="keyword">int</span><span class="special">>::</span><span class="identifier">type</span></code> + </p> + </td> +<td> + <p> + <code class="computeroutput"><span class="keyword">unsigned</span> <span class="keyword">int</span></code> + </p> + </td> +</tr> +<tr> +<td> + <p> + <code class="computeroutput"><span class="identifier">make_unsigned</span><span class="special"><</span><span class="keyword">unsigned</span> <span class="keyword">int</span> + <span class="keyword">const</span><span class="special">>::</span><span class="identifier">type</span></code> + </p> + </td> +<td> + <p> + <code class="computeroutput"><span class="keyword">unsigned</span> <span class="keyword">int</span> + <span class="keyword">const</span></code> + </p> + </td> +</tr> +<tr> +<td> + <p> + <code class="computeroutput"><span class="identifier">make_unsigned</span><span class="special"><</span><span class="keyword">const</span> <span class="keyword">unsigned</span> + <span class="keyword">long</span> <span class="keyword">long</span><span class="special">>::</span><span class="identifier">type</span></code> + </p> + </td> +<td> + <p> + <code class="computeroutput"><span class="keyword">const</span> <span class="keyword">unsigned</span> + <span class="keyword">long</span> <span class="keyword">long</span></code> + </p> + </td> +</tr> +<tr> +<td> + <p> + <code class="computeroutput"><span class="identifier">make_unsigned</span><span class="special"><</span><span class="identifier">my_enum</span><span class="special">>::</span><span class="identifier">type</span></code> + </p> + </td> +<td> + <p> + An unsigned integer type with the same width as the enum. + </p> + </td> +</tr> +<tr> +<td> + <p> + <code class="computeroutput"><span class="identifier">make_unsigned</span><span class="special"><</span><span class="keyword">wchar_t</span><span class="special">>::</span><span class="identifier">type</span></code> + </p> + </td> +<td> + <p> + An unsigned integer type with the same width as wchar_t. + </p> + </td> +</tr> +</tbody> +</table></div> +</div> +<br class="table-break"> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="make_signed.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="promote.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/reference/promote.html b/libs/type_traits/doc/html/boost_typetraits/reference/promote.html new file mode 100644 index 0000000000..a2677fb45e --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/reference/promote.html @@ -0,0 +1,131 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>promote</title> +<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../reference.html" title="Alphabetical Reference"> +<link rel="prev" href="make_unsigned.html" title="make_unsigned"> +<link rel="next" href="rank.html" title="rank"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td> +<td align="center"><a href="../../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="make_unsigned.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="rank.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h3 class="title"> +<a name="boost_typetraits.reference.promote"></a><a class="link" href="promote.html" title="promote">promote</a> +</h3></div></div></div> +<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">promote</span> +<span class="special">{</span> + <span class="keyword">typedef</span> <em class="replaceable"><code>see-below</code></em> <span class="identifier">type</span><span class="special">;</span> +<span class="special">};</span> +</pre> +<p> + <span class="bold"><strong>type:</strong></span> If integral or floating point promotion + can be applied to an rvalue of type <code class="computeroutput"><span class="identifier">T</span></code>, + then applies integral and floating point promotions to <code class="computeroutput"><span class="identifier">T</span></code> + and keeps cv-qualifiers of <code class="computeroutput"><span class="identifier">T</span></code>, + otherwise leaves <code class="computeroutput"><span class="identifier">T</span></code> unchanged. + See also <a class="link" href="integral_promotion.html" title="integral_promotion">integral_promotion</a> + and <a class="link" href="floating_point_promotion.html" title="floating_point_promotion">floating_point_promotion</a>. + </p> +<p> + <span class="bold"><strong>C++ Standard Reference:</strong></span> 4.5 except 4.5/3 + (integral bit-field) and 4.6. + </p> +<p> + <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"> <span class="preprocessor">#include</span> + <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">promote</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + </p> +<div class="table"> +<a name="boost_typetraits.reference.promote.examples"></a><p class="title"><b>Table 1.24. Examples</b></p> +<div class="table-contents"><table class="table" summary="Examples"> +<colgroup> +<col> +<col> +</colgroup> +<thead><tr> +<th> + <p> + Expression + </p> + </th> +<th> + <p> + Result Type + </p> + </th> +</tr></thead> +<tbody> +<tr> +<td> + <p> + <code class="computeroutput"><span class="identifier">promote</span><span class="special"><</span><span class="keyword">short</span> <span class="keyword">volatile</span><span class="special">>::</span><span class="identifier">type</span></code> + </p> + </td> +<td> + <p> + <code class="computeroutput"><span class="keyword">int</span> <span class="keyword">volatile</span></code> + </p> + </td> +</tr> +<tr> +<td> + <p> + <code class="computeroutput"><span class="identifier">promote</span><span class="special"><</span><span class="keyword">float</span> <span class="keyword">const</span><span class="special">>::</span><span class="identifier">type</span></code> + </p> + </td> +<td> + <p> + <code class="computeroutput"><span class="keyword">double</span> <span class="keyword">const</span></code> + </p> + </td> +</tr> +<tr> +<td> + <p> + <code class="computeroutput"><span class="identifier">promote</span><span class="special"><</span><span class="keyword">short</span><span class="special">&>::</span><span class="identifier">type</span></code> + </p> + </td> +<td> + <p> + <code class="computeroutput"><span class="keyword">short</span><span class="special">&</span></code> + </p> + </td> +</tr> +</tbody> +</table></div> +</div> +<br class="table-break"> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="make_unsigned.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="rank.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/reference/rank.html b/libs/type_traits/doc/html/boost_typetraits/reference/rank.html new file mode 100644 index 0000000000..20381399ae --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/reference/rank.html @@ -0,0 +1,95 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>rank</title> +<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../reference.html" title="Alphabetical Reference"> +<link rel="prev" href="promote.html" title="promote"> +<link rel="next" href="remove_all_extents.html" title="remove_all_extents"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td> +<td align="center"><a href="../../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="promote.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="remove_all_extents.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h3 class="title"> +<a name="boost_typetraits.reference.rank"></a><a class="link" href="rank.html" title="rank">rank</a> +</h3></div></div></div> +<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">rank</span> <span class="special">:</span> <span class="keyword">public</span> <a class="link" href="integral_constant.html" title="integral_constant">integral_constant</a><span class="special"><</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span><span class="special">,</span> <span class="identifier">RANK</span><span class="special">(</span><span class="identifier">T</span><span class="special">)></span> <span class="special">{};</span> +</pre> +<p> + <span class="bold"><strong>Inherits:</strong></span> Class template rank inherits from + <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">integral_constant</a><span class="special"><</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span><span class="special">,</span> <span class="identifier">RANK</span><span class="special">(</span><span class="identifier">T</span><span class="special">)></span></code>, + where <code class="computeroutput"><span class="identifier">RANK</span><span class="special">(</span><span class="identifier">T</span><span class="special">)</span></code> is the + number of array dimensions in type <code class="computeroutput"><span class="identifier">T</span></code>. + </p> +<p> + If <code class="computeroutput"><span class="identifier">T</span></code> is not a (built-in) + array type, then <code class="computeroutput"><span class="identifier">RANK</span><span class="special">(</span><span class="identifier">T</span><span class="special">)</span></code> is zero. + </p> +<p> + <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"> <span class="preprocessor">#include</span> + <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">rank</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + </p> +<p> + <span class="bold"><strong>Examples:</strong></span> + </p> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">rank</span><span class="special"><</span><span class="keyword">int</span><span class="special">[]></span></code> + inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">integral_constant</a><span class="special"><</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span><span class="special">,</span> <span class="number">1</span><span class="special">></span></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">rank</span><span class="special"><</span><span class="keyword">double</span><span class="special">[</span><span class="number">2</span><span class="special">][</span><span class="number">3</span><span class="special">][</span><span class="number">4</span><span class="special">]>::</span><span class="identifier">type</span></code> is the type <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">integral_constant</a><span class="special"><</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span><span class="special">,</span> <span class="number">3</span><span class="special">></span></code>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">rank</span><span class="special"><</span><span class="keyword">int</span><span class="special">[</span><span class="number">1</span><span class="special">]>::</span><span class="identifier">value</span></code> + is an integral constant expression that evaluates to <span class="emphasis"><em>1</em></span>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">rank</span><span class="special"><</span><span class="keyword">int</span><span class="special">[][</span><span class="number">2</span><span class="special">]>::</span><span class="identifier">value</span></code> + is an integral constant expression that evaluates to <span class="emphasis"><em>2</em></span>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">rank</span><span class="special"><</span><span class="keyword">int</span><span class="special">*>::</span><span class="identifier">value</span></code> is an integral constant expression + that evaluates to <span class="emphasis"><em>0</em></span>. + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">rank</span><span class="special"><</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">array</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="number">3</span><span class="special">></span> <span class="special">>::</span><span class="identifier">value</span></code> is an integral constant expression + that evaluates to <span class="emphasis"><em>0</em></span>: <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">array</span></code> + is a class type and <span class="bold"><strong>not an array type</strong></span>! + </p></blockquote></div> +<div class="blockquote"><blockquote class="blockquote"><p> + <code class="computeroutput"><span class="identifier">rank</span><span class="special"><</span><span class="identifier">T</span><span class="special">>::</span><span class="identifier">value_type</span></code> is the type <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span></code>. + </p></blockquote></div> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="promote.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="remove_all_extents.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/reference/remove_all_extents.html b/libs/type_traits/doc/html/boost_typetraits/reference/remove_all_extents.html new file mode 100644 index 0000000000..aed2427402 --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/reference/remove_all_extents.html @@ -0,0 +1,160 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>remove_all_extents</title> +<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../reference.html" title="Alphabetical Reference"> +<link rel="prev" href="rank.html" title="rank"> +<link rel="next" href="remove_const.html" title="remove_const"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td> +<td align="center"><a href="../../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="rank.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="remove_const.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h3 class="title"> +<a name="boost_typetraits.reference.remove_all_extents"></a><a class="link" href="remove_all_extents.html" title="remove_all_extents">remove_all_extents</a> +</h3></div></div></div> +<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">remove_all_extents</span> +<span class="special">{</span> + <span class="keyword">typedef</span> <em class="replaceable"><code>see-below</code></em> <span class="identifier">type</span><span class="special">;</span> +<span class="special">};</span> +</pre> +<p> + <span class="bold"><strong>type:</strong></span> If <code class="computeroutput"><span class="identifier">T</span></code> + is an array type, then removes all of the array bounds on <code class="computeroutput"><span class="identifier">T</span></code>, + otherwise leaves <code class="computeroutput"><span class="identifier">T</span></code> unchanged. + </p> +<p> + <span class="bold"><strong>C++ Standard Reference:</strong></span> 8.3.4. + </p> +<p> + <span class="bold"><strong>Compiler Compatibility:</strong></span> If the compiler + does not support partial specialization of class-templates then this template + will compile, but the member <code class="computeroutput"><span class="identifier">type</span></code> + will always be the same as type <code class="computeroutput"><span class="identifier">T</span></code> + except where <a class="link" href="../category/transform.html#boost_typetraits.category.transform.broken_compiler_workarounds_">compiler + workarounds</a> have been applied. + </p> +<p> + <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"> <span class="preprocessor">#include</span> + <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">remove_all_extents</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + </p> +<div class="table"> +<a name="boost_typetraits.reference.remove_all_extents.examples"></a><p class="title"><b>Table 1.25. Examples</b></p> +<div class="table-contents"><table class="table" summary="Examples"> +<colgroup> +<col> +<col> +</colgroup> +<thead><tr> +<th> + <p> + Expression + </p> + </th> +<th> + <p> + Result Type + </p> + </th> +</tr></thead> +<tbody> +<tr> +<td> + <p> + <code class="computeroutput"><span class="identifier">remove_all_extents</span><span class="special"><</span><span class="keyword">int</span><span class="special">>::</span><span class="identifier">type</span></code> + </p> + </td> +<td> + <p> + <code class="computeroutput"><span class="keyword">int</span></code> + </p> + </td> +</tr> +<tr> +<td> + <p> + <code class="computeroutput"><span class="identifier">remove_all_extents</span><span class="special"><</span><span class="keyword">int</span> + <span class="keyword">const</span><span class="special">[</span><span class="number">2</span><span class="special">]>::</span><span class="identifier">type</span></code> + </p> + </td> +<td> + <p> + <code class="computeroutput"><span class="keyword">int</span> <span class="keyword">const</span></code> + </p> + </td> +</tr> +<tr> +<td> + <p> + <code class="computeroutput"><span class="identifier">remove_all_extents</span><span class="special"><</span><span class="keyword">int</span><span class="special">[][</span><span class="number">2</span><span class="special">]>::</span><span class="identifier">type</span></code> + </p> + </td> +<td> + <p> + <code class="computeroutput"><span class="keyword">int</span></code> + </p> + </td> +</tr> +<tr> +<td> + <p> + <code class="computeroutput"><span class="identifier">remove_all_extents</span><span class="special"><</span><span class="keyword">int</span><span class="special">[</span><span class="number">2</span><span class="special">][</span><span class="number">3</span><span class="special">][</span><span class="number">4</span><span class="special">]>::</span><span class="identifier">type</span></code> + </p> + </td> +<td> + <p> + <code class="computeroutput"><span class="keyword">int</span></code> + </p> + </td> +</tr> +<tr> +<td> + <p> + <code class="computeroutput"><span class="identifier">remove_all_extents</span><span class="special"><</span><span class="keyword">int</span> + <span class="keyword">const</span><span class="special">*>::</span><span class="identifier">type</span></code> + </p> + </td> +<td> + <p> + <code class="computeroutput"><span class="keyword">int</span> <span class="keyword">const</span><span class="special">*</span></code> + </p> + </td> +</tr> +</tbody> +</table></div> +</div> +<br class="table-break"> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="rank.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="remove_const.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/reference/remove_const.html b/libs/type_traits/doc/html/boost_typetraits/reference/remove_const.html new file mode 100644 index 0000000000..93c685b65d --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/reference/remove_const.html @@ -0,0 +1,158 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>remove_const</title> +<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../reference.html" title="Alphabetical Reference"> +<link rel="prev" href="remove_all_extents.html" title="remove_all_extents"> +<link rel="next" href="remove_cv.html" title="remove_cv"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td> +<td align="center"><a href="../../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="remove_all_extents.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="remove_cv.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h3 class="title"> +<a name="boost_typetraits.reference.remove_const"></a><a class="link" href="remove_const.html" title="remove_const">remove_const</a> +</h3></div></div></div> +<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">remove_const</span> +<span class="special">{</span> + <span class="keyword">typedef</span> <em class="replaceable"><code>see-below</code></em> <span class="identifier">type</span><span class="special">;</span> +<span class="special">};</span> +</pre> +<p> + <span class="bold"><strong>type:</strong></span> The same type as <code class="computeroutput"><span class="identifier">T</span></code>, + but with any <span class="emphasis"><em>top level</em></span> const-qualifier removed. + </p> +<p> + <span class="bold"><strong>C++ Standard Reference:</strong></span> 3.9.3. + </p> +<p> + <span class="bold"><strong>Compiler Compatibility:</strong></span> If the compiler + does not support partial specialization of class-templates then this template + will compile, but the member <code class="computeroutput"><span class="identifier">type</span></code> + will always be the same as type <code class="computeroutput"><span class="identifier">T</span></code> + except where <a class="link" href="../category/transform.html#boost_typetraits.category.transform.broken_compiler_workarounds_">compiler + workarounds</a> have been applied. + </p> +<p> + <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"> <span class="preprocessor">#include</span> + <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">remove_const</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + </p> +<div class="table"> +<a name="boost_typetraits.reference.remove_const.examples"></a><p class="title"><b>Table 1.26. Examples</b></p> +<div class="table-contents"><table class="table" summary="Examples"> +<colgroup> +<col> +<col> +</colgroup> +<thead><tr> +<th> + <p> + Expression + </p> + </th> +<th> + <p> + Result Type + </p> + </th> +</tr></thead> +<tbody> +<tr> +<td> + <p> + <code class="computeroutput"><span class="identifier">remove_const</span><span class="special"><</span><span class="keyword">int</span><span class="special">>::</span><span class="identifier">type</span></code> + </p> + </td> +<td> + <p> + <code class="computeroutput"><span class="keyword">int</span></code> + </p> + </td> +</tr> +<tr> +<td> + <p> + <code class="computeroutput"><span class="identifier">remove_const</span><span class="special"><</span><span class="keyword">int</span> <span class="keyword">const</span><span class="special">>::</span><span class="identifier">type</span></code> + </p> + </td> +<td> + <p> + <code class="computeroutput"><span class="keyword">int</span></code> + </p> + </td> +</tr> +<tr> +<td> + <p> + <code class="computeroutput"><span class="identifier">remove_const</span><span class="special"><</span><span class="keyword">int</span> <span class="keyword">const</span> + <span class="keyword">volatile</span><span class="special">>::</span><span class="identifier">type</span></code> + </p> + </td> +<td> + <p> + <code class="computeroutput"><span class="keyword">int</span> <span class="keyword">volatile</span></code> + </p> + </td> +</tr> +<tr> +<td> + <p> + <code class="computeroutput"><span class="identifier">remove_const</span><span class="special"><</span><span class="keyword">int</span> <span class="keyword">const</span><span class="special">&>::</span><span class="identifier">type</span></code> + </p> + </td> +<td> + <p> + <code class="computeroutput"><span class="keyword">int</span> <span class="keyword">const</span><span class="special">&</span></code> + </p> + </td> +</tr> +<tr> +<td> + <p> + <code class="computeroutput"><span class="identifier">remove_const</span><span class="special"><</span><span class="keyword">int</span> <span class="keyword">const</span><span class="special">*>::</span><span class="identifier">type</span></code> + </p> + </td> +<td> + <p> + <code class="computeroutput"><span class="keyword">int</span> <span class="keyword">const</span><span class="special">*</span></code> + </p> + </td> +</tr> +</tbody> +</table></div> +</div> +<br class="table-break"> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="remove_all_extents.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="remove_cv.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/reference/remove_cv.html b/libs/type_traits/doc/html/boost_typetraits/reference/remove_cv.html new file mode 100644 index 0000000000..2ac7a0bc47 --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/reference/remove_cv.html @@ -0,0 +1,158 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>remove_cv</title> +<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../reference.html" title="Alphabetical Reference"> +<link rel="prev" href="remove_const.html" title="remove_const"> +<link rel="next" href="remove_extent.html" title="remove_extent"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td> +<td align="center"><a href="../../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="remove_const.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="remove_extent.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h3 class="title"> +<a name="boost_typetraits.reference.remove_cv"></a><a class="link" href="remove_cv.html" title="remove_cv">remove_cv</a> +</h3></div></div></div> +<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">remove_cv</span> +<span class="special">{</span> + <span class="keyword">typedef</span> <em class="replaceable"><code>see-below</code></em> <span class="identifier">type</span><span class="special">;</span> +<span class="special">};</span> +</pre> +<p> + <span class="bold"><strong>type:</strong></span> The same type as <code class="computeroutput"><span class="identifier">T</span></code>, + but with any <span class="emphasis"><em>top level</em></span> cv-qualifiers removed. + </p> +<p> + <span class="bold"><strong>C++ Standard Reference:</strong></span> 3.9.3. + </p> +<p> + <span class="bold"><strong>Compiler Compatibility:</strong></span> If the compiler + does not support partial specialization of class-templates then this template + will compile, but the member <code class="computeroutput"><span class="identifier">type</span></code> + will always be the same as type <code class="computeroutput"><span class="identifier">T</span></code> + except where <a class="link" href="../category/transform.html#boost_typetraits.category.transform.broken_compiler_workarounds_">compiler + workarounds</a> have been applied. + </p> +<p> + <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"> <span class="preprocessor">#include</span> + <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">remove_cv</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + </p> +<div class="table"> +<a name="boost_typetraits.reference.remove_cv.examples"></a><p class="title"><b>Table 1.27. Examples</b></p> +<div class="table-contents"><table class="table" summary="Examples"> +<colgroup> +<col> +<col> +</colgroup> +<thead><tr> +<th> + <p> + Expression + </p> + </th> +<th> + <p> + Result Type + </p> + </th> +</tr></thead> +<tbody> +<tr> +<td> + <p> + <code class="computeroutput"><span class="identifier">remove_cv</span><span class="special"><</span><span class="keyword">int</span><span class="special">>::</span><span class="identifier">type</span></code> + </p> + </td> +<td> + <p> + <code class="computeroutput"><span class="keyword">int</span></code> + </p> + </td> +</tr> +<tr> +<td> + <p> + <code class="computeroutput"><span class="identifier">remove_cv</span><span class="special"><</span><span class="keyword">int</span> <span class="keyword">const</span><span class="special">>::</span><span class="identifier">type</span></code> + </p> + </td> +<td> + <p> + <code class="computeroutput"><span class="keyword">int</span></code> + </p> + </td> +</tr> +<tr> +<td> + <p> + <code class="computeroutput"><span class="identifier">remove_cv</span><span class="special"><</span><span class="keyword">int</span> <span class="keyword">const</span> + <span class="keyword">volatile</span><span class="special">>::</span><span class="identifier">type</span></code> + </p> + </td> +<td> + <p> + <code class="computeroutput"><span class="keyword">int</span></code> + </p> + </td> +</tr> +<tr> +<td> + <p> + <code class="computeroutput"><span class="identifier">remove_cv</span><span class="special"><</span><span class="keyword">int</span> <span class="keyword">const</span><span class="special">&>::</span><span class="identifier">type</span></code> + </p> + </td> +<td> + <p> + <code class="computeroutput"><span class="keyword">int</span> <span class="keyword">const</span><span class="special">&</span></code> + </p> + </td> +</tr> +<tr> +<td> + <p> + <code class="computeroutput"><span class="identifier">remove_cv</span><span class="special"><</span><span class="keyword">int</span> <span class="keyword">const</span><span class="special">*>::</span><span class="identifier">type</span></code> + </p> + </td> +<td> + <p> + <code class="computeroutput"><span class="keyword">int</span> <span class="keyword">const</span><span class="special">*</span></code> + </p> + </td> +</tr> +</tbody> +</table></div> +</div> +<br class="table-break"> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="remove_const.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="remove_extent.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/reference/remove_extent.html b/libs/type_traits/doc/html/boost_typetraits/reference/remove_extent.html new file mode 100644 index 0000000000..975fb2fbf5 --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/reference/remove_extent.html @@ -0,0 +1,158 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>remove_extent</title> +<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../reference.html" title="Alphabetical Reference"> +<link rel="prev" href="remove_cv.html" title="remove_cv"> +<link rel="next" href="remove_pointer.html" title="remove_pointer"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td> +<td align="center"><a href="../../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="remove_cv.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="remove_pointer.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h3 class="title"> +<a name="boost_typetraits.reference.remove_extent"></a><a class="link" href="remove_extent.html" title="remove_extent">remove_extent</a> +</h3></div></div></div> +<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">remove_extent</span> +<span class="special">{</span> + <span class="keyword">typedef</span> <em class="replaceable"><code>see-below</code></em> <span class="identifier">type</span><span class="special">;</span> +<span class="special">};</span> +</pre> +<p> + <span class="bold"><strong>type:</strong></span> If <code class="computeroutput"><span class="identifier">T</span></code> + is an array type, then removes the topmost array bound, otherwise leaves + <code class="computeroutput"><span class="identifier">T</span></code> unchanged. + </p> +<p> + <span class="bold"><strong>C++ Standard Reference:</strong></span> 8.3.4. + </p> +<p> + <span class="bold"><strong>Compiler Compatibility:</strong></span> If the compiler + does not support partial specialization of class-templates then this template + will compile, but the member <code class="computeroutput"><span class="identifier">type</span></code> + will always be the same as type <code class="computeroutput"><span class="identifier">T</span></code> + except where <a class="link" href="../category/transform.html#boost_typetraits.category.transform.broken_compiler_workarounds_">compiler + workarounds</a> have been applied. + </p> +<p> + <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"> <span class="preprocessor">#include</span> + <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">remove_extent</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + </p> +<div class="table"> +<a name="boost_typetraits.reference.remove_extent.examples"></a><p class="title"><b>Table 1.28. Examples</b></p> +<div class="table-contents"><table class="table" summary="Examples"> +<colgroup> +<col> +<col> +</colgroup> +<thead><tr> +<th> + <p> + Expression + </p> + </th> +<th> + <p> + Result Type + </p> + </th> +</tr></thead> +<tbody> +<tr> +<td> + <p> + <code class="computeroutput"><span class="identifier">remove_extent</span><span class="special"><</span><span class="keyword">int</span><span class="special">>::</span><span class="identifier">type</span></code> + </p> + </td> +<td> + <p> + <code class="computeroutput"><span class="keyword">int</span></code> + </p> + </td> +</tr> +<tr> +<td> + <p> + <code class="computeroutput"><span class="identifier">remove_extent</span><span class="special"><</span><span class="keyword">int</span> <span class="keyword">const</span><span class="special">[</span><span class="number">2</span><span class="special">]>::</span><span class="identifier">type</span></code> + </p> + </td> +<td> + <p> + <code class="computeroutput"><span class="keyword">int</span> <span class="keyword">const</span></code> + </p> + </td> +</tr> +<tr> +<td> + <p> + <code class="computeroutput"><span class="identifier">remove_extent</span><span class="special"><</span><span class="keyword">int</span><span class="special">[</span><span class="number">2</span><span class="special">][</span><span class="number">4</span><span class="special">]>::</span><span class="identifier">type</span></code> + </p> + </td> +<td> + <p> + <code class="computeroutput"><span class="keyword">int</span><span class="special">[</span><span class="number">4</span><span class="special">]</span></code> + </p> + </td> +</tr> +<tr> +<td> + <p> + <code class="computeroutput"><span class="identifier">remove_extent</span><span class="special"><</span><span class="keyword">int</span><span class="special">[][</span><span class="number">2</span><span class="special">]>::</span><span class="identifier">type</span></code> + </p> + </td> +<td> + <p> + <code class="computeroutput"><span class="keyword">int</span><span class="special">[</span><span class="number">2</span><span class="special">]</span></code> + </p> + </td> +</tr> +<tr> +<td> + <p> + <code class="computeroutput"><span class="identifier">remove_extent</span><span class="special"><</span><span class="keyword">int</span> <span class="keyword">const</span><span class="special">*>::</span><span class="identifier">type</span></code> + </p> + </td> +<td> + <p> + <code class="computeroutput"><span class="keyword">int</span> <span class="keyword">const</span><span class="special">*</span></code> + </p> + </td> +</tr> +</tbody> +</table></div> +</div> +<br class="table-break"> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="remove_cv.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="remove_pointer.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/reference/remove_pointer.html b/libs/type_traits/doc/html/boost_typetraits/reference/remove_pointer.html new file mode 100644 index 0000000000..e89e97533a --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/reference/remove_pointer.html @@ -0,0 +1,161 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>remove_pointer</title> +<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../reference.html" title="Alphabetical Reference"> +<link rel="prev" href="remove_extent.html" title="remove_extent"> +<link rel="next" href="remove_reference.html" title="remove_reference"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td> +<td align="center"><a href="../../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="remove_extent.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="remove_reference.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h3 class="title"> +<a name="boost_typetraits.reference.remove_pointer"></a><a class="link" href="remove_pointer.html" title="remove_pointer">remove_pointer</a> +</h3></div></div></div> +<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">remove_pointer</span> +<span class="special">{</span> + <span class="keyword">typedef</span> <em class="replaceable"><code>see-below</code></em> <span class="identifier">type</span><span class="special">;</span> +<span class="special">};</span> +</pre> +<p> + <span class="bold"><strong>type:</strong></span> The same type as <code class="computeroutput"><span class="identifier">T</span></code>, + but with any pointer modifier removed. Note that pointers to members are + left unchanged: removing the pointer decoration would result in an invalid + type. + </p> +<p> + <span class="bold"><strong>C++ Standard Reference:</strong></span> 8.3.1. + </p> +<p> + <span class="bold"><strong>Compiler Compatibility:</strong></span> If the compiler + does not support partial specialization of class-templates then this template + will compile, but the member <code class="computeroutput"><span class="identifier">type</span></code> + will always be the same as type <code class="computeroutput"><span class="identifier">T</span></code> + except where <a class="link" href="../category/transform.html#boost_typetraits.category.transform.broken_compiler_workarounds_">compiler + workarounds</a> have been applied. + </p> +<p> + <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"> <span class="preprocessor">#include</span> + <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">remove_pointer</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + </p> +<div class="table"> +<a name="boost_typetraits.reference.remove_pointer.examples"></a><p class="title"><b>Table 1.29. Examples</b></p> +<div class="table-contents"><table class="table" summary="Examples"> +<colgroup> +<col> +<col> +</colgroup> +<thead><tr> +<th> + <p> + Expression + </p> + </th> +<th> + <p> + Result Type + </p> + </th> +</tr></thead> +<tbody> +<tr> +<td> + <p> + <code class="computeroutput"><span class="identifier">remove_pointer</span><span class="special"><</span><span class="keyword">int</span><span class="special">>::</span><span class="identifier">type</span></code> + </p> + </td> +<td> + <p> + <code class="computeroutput"><span class="keyword">int</span></code> + </p> + </td> +</tr> +<tr> +<td> + <p> + <code class="computeroutput"><span class="identifier">remove_pointer</span><span class="special"><</span><span class="keyword">int</span> + <span class="keyword">const</span><span class="special">*>::</span><span class="identifier">type</span></code> + </p> + </td> +<td> + <p> + <code class="computeroutput"><span class="keyword">int</span> <span class="keyword">const</span></code> + </p> + </td> +</tr> +<tr> +<td> + <p> + <code class="computeroutput"><span class="identifier">remove_pointer</span><span class="special"><</span><span class="keyword">int</span> + <span class="keyword">const</span><span class="special">**>::</span><span class="identifier">type</span></code> + </p> + </td> +<td> + <p> + <code class="computeroutput"><span class="keyword">int</span> <span class="keyword">const</span><span class="special">*</span></code> + </p> + </td> +</tr> +<tr> +<td> + <p> + <code class="computeroutput"><span class="identifier">remove_pointer</span><span class="special"><</span><span class="keyword">int</span><span class="special">&>::</span><span class="identifier">type</span></code> + </p> + </td> +<td> + <p> + <code class="computeroutput"><span class="keyword">int</span><span class="special">&</span></code> + </p> + </td> +</tr> +<tr> +<td> + <p> + <code class="computeroutput"><span class="identifier">remove_pointer</span><span class="special"><</span><span class="keyword">int</span><span class="special">*&>::</span><span class="identifier">type</span></code> + </p> + </td> +<td> + <p> + <code class="computeroutput"><span class="keyword">int</span><span class="special">*&</span></code> + </p> + </td> +</tr> +</tbody> +</table></div> +</div> +<br class="table-break"> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="remove_extent.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="remove_reference.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/reference/remove_reference.html b/libs/type_traits/doc/html/boost_typetraits/reference/remove_reference.html new file mode 100644 index 0000000000..96b13bbf06 --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/reference/remove_reference.html @@ -0,0 +1,158 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>remove_reference</title> +<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../reference.html" title="Alphabetical Reference"> +<link rel="prev" href="remove_pointer.html" title="remove_pointer"> +<link rel="next" href="remove_volatile.html" title="remove_volatile"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td> +<td align="center"><a href="../../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="remove_pointer.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="remove_volatile.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h3 class="title"> +<a name="boost_typetraits.reference.remove_reference"></a><a class="link" href="remove_reference.html" title="remove_reference">remove_reference</a> +</h3></div></div></div> +<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">remove_reference</span> +<span class="special">{</span> + <span class="keyword">typedef</span> <em class="replaceable"><code>see-below</code></em> <span class="identifier">type</span><span class="special">;</span> +<span class="special">};</span> +</pre> +<p> + <span class="bold"><strong>type:</strong></span> The same type as <code class="computeroutput"><span class="identifier">T</span></code>, + but with any reference modifier removed. + </p> +<p> + <span class="bold"><strong>C++ Standard Reference:</strong></span> 8.3.2. + </p> +<p> + <span class="bold"><strong>Compiler Compatibility:</strong></span> If the compiler + does not support partial specialization of class-templates then this template + will compile, but the member <code class="computeroutput"><span class="identifier">type</span></code> + will always be the same as type <code class="computeroutput"><span class="identifier">T</span></code> + except where <a class="link" href="../category/transform.html#boost_typetraits.category.transform.broken_compiler_workarounds_">compiler + workarounds</a> have been applied. + </p> +<p> + <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"> <span class="preprocessor">#include</span> + <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">remove_reference</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + </p> +<div class="table"> +<a name="boost_typetraits.reference.remove_reference.examples"></a><p class="title"><b>Table 1.30. Examples</b></p> +<div class="table-contents"><table class="table" summary="Examples"> +<colgroup> +<col> +<col> +</colgroup> +<thead><tr> +<th> + <p> + Expression + </p> + </th> +<th> + <p> + Result Type + </p> + </th> +</tr></thead> +<tbody> +<tr> +<td> + <p> + <code class="computeroutput"><span class="identifier">remove_reference</span><span class="special"><</span><span class="keyword">int</span><span class="special">>::</span><span class="identifier">type</span></code> + </p> + </td> +<td> + <p> + <code class="computeroutput"><span class="keyword">int</span></code> + </p> + </td> +</tr> +<tr> +<td> + <p> + <code class="computeroutput"><span class="identifier">remove_reference</span><span class="special"><</span><span class="keyword">int</span> + <span class="keyword">const</span><span class="special">&>::</span><span class="identifier">type</span></code> + </p> + </td> +<td> + <p> + <code class="computeroutput"><span class="keyword">int</span> <span class="keyword">const</span></code> + </p> + </td> +</tr> +<tr> +<td> + <p> + <code class="computeroutput"><span class="identifier">remove_reference</span><span class="special"><</span><span class="keyword">int</span><span class="special">&&>::</span><span class="identifier">type</span></code> + </p> + </td> +<td> + <p> + <code class="computeroutput"><span class="keyword">int</span></code> + </p> + </td> +</tr> +<tr> +<td> + <p> + <code class="computeroutput"><span class="identifier">remove_reference</span><span class="special"><</span><span class="keyword">int</span><span class="special">*>::</span><span class="identifier">type</span></code> + </p> + </td> +<td> + <p> + <code class="computeroutput"><span class="keyword">int</span><span class="special">*</span></code> + </p> + </td> +</tr> +<tr> +<td> + <p> + <code class="computeroutput"><span class="identifier">remove_reference</span><span class="special"><</span><span class="keyword">int</span><span class="special">*&>::</span><span class="identifier">type</span></code> + </p> + </td> +<td> + <p> + <code class="computeroutput"><span class="keyword">int</span><span class="special">*</span></code> + </p> + </td> +</tr> +</tbody> +</table></div> +</div> +<br class="table-break"> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="remove_pointer.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="remove_volatile.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/reference/remove_volatile.html b/libs/type_traits/doc/html/boost_typetraits/reference/remove_volatile.html new file mode 100644 index 0000000000..f4c9f879e0 --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/reference/remove_volatile.html @@ -0,0 +1,161 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>remove_volatile</title> +<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../reference.html" title="Alphabetical Reference"> +<link rel="prev" href="remove_reference.html" title="remove_reference"> +<link rel="next" href="type_with_alignment.html" title="type_with_alignment"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td> +<td align="center"><a href="../../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="remove_reference.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="type_with_alignment.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h3 class="title"> +<a name="boost_typetraits.reference.remove_volatile"></a><a class="link" href="remove_volatile.html" title="remove_volatile">remove_volatile</a> +</h3></div></div></div> +<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">remove_volatile</span> +<span class="special">{</span> + <span class="keyword">typedef</span> <em class="replaceable"><code>see-below</code></em> <span class="identifier">type</span><span class="special">;</span> +<span class="special">};</span> +</pre> +<p> + <span class="bold"><strong>type:</strong></span> The same type as <code class="computeroutput"><span class="identifier">T</span></code>, + but with any <span class="emphasis"><em>top level</em></span> volatile-qualifier removed. + </p> +<p> + <span class="bold"><strong>C++ Standard Reference:</strong></span> 3.9.3. + </p> +<p> + <span class="bold"><strong>Compiler Compatibility:</strong></span> If the compiler + does not support partial specialization of class-templates then this template + will compile, but the member <code class="computeroutput"><span class="identifier">type</span></code> + will always be the same as type <code class="computeroutput"><span class="identifier">T</span></code> + except where <a class="link" href="../category/transform.html#boost_typetraits.category.transform.broken_compiler_workarounds_">compiler + workarounds</a> have been applied. + </p> +<p> + <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"> <span class="preprocessor">#include</span> + <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">remove_volatile</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + </p> +<div class="table"> +<a name="boost_typetraits.reference.remove_volatile.examples"></a><p class="title"><b>Table 1.31. Examples</b></p> +<div class="table-contents"><table class="table" summary="Examples"> +<colgroup> +<col> +<col> +</colgroup> +<thead><tr> +<th> + <p> + Expression + </p> + </th> +<th> + <p> + Result Type + </p> + </th> +</tr></thead> +<tbody> +<tr> +<td> + <p> + <code class="computeroutput"><span class="identifier">remove_volatile</span><span class="special"><</span><span class="keyword">int</span><span class="special">>::</span><span class="identifier">type</span></code> + </p> + </td> +<td> + <p> + <code class="computeroutput"><span class="keyword">int</span></code> + </p> + </td> +</tr> +<tr> +<td> + <p> + <code class="computeroutput"><span class="identifier">remove_volatile</span><span class="special"><</span><span class="keyword">int</span> + <span class="keyword">volatile</span><span class="special">>::</span><span class="identifier">type</span></code> + </p> + </td> +<td> + <p> + <code class="computeroutput"><span class="keyword">int</span></code> + </p> + </td> +</tr> +<tr> +<td> + <p> + <code class="computeroutput"><span class="identifier">remove_volatile</span><span class="special"><</span><span class="keyword">int</span> + <span class="keyword">const</span> <span class="keyword">volatile</span><span class="special">>::</span><span class="identifier">type</span></code> + </p> + </td> +<td> + <p> + <code class="computeroutput"><span class="keyword">int</span> <span class="keyword">const</span></code> + </p> + </td> +</tr> +<tr> +<td> + <p> + <code class="computeroutput"><span class="identifier">remove_volatile</span><span class="special"><</span><span class="keyword">int</span> + <span class="keyword">volatile</span><span class="special">&>::</span><span class="identifier">type</span></code> + </p> + </td> +<td> + <p> + <code class="computeroutput"><span class="keyword">int</span> <span class="keyword">const</span><span class="special">&</span></code> + </p> + </td> +</tr> +<tr> +<td> + <p> + <code class="computeroutput"><span class="identifier">remove_volatile</span><span class="special"><</span><span class="keyword">int</span> + <span class="keyword">volatile</span><span class="special">*>::</span><span class="identifier">type</span></code> + </p> + </td> +<td> + <p> + <code class="computeroutput"><span class="keyword">int</span> <span class="keyword">const</span><span class="special">*</span></code> + </p> + </td> +</tr> +</tbody> +</table></div> +</div> +<br class="table-break"> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="remove_reference.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="type_with_alignment.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/reference/type_with_alignment.html b/libs/type_traits/doc/html/boost_typetraits/reference/type_with_alignment.html new file mode 100644 index 0000000000..6ba1d51fc8 --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/reference/type_with_alignment.html @@ -0,0 +1,62 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>type_with_alignment</title> +<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../reference.html" title="Alphabetical Reference"> +<link rel="prev" href="remove_volatile.html" title="remove_volatile"> +<link rel="next" href="../history.html" title="History"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td> +<td align="center"><a href="../../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="remove_volatile.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="../history.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h3 class="title"> +<a name="boost_typetraits.reference.type_with_alignment"></a><a class="link" href="type_with_alignment.html" title="type_with_alignment">type_with_alignment</a> +</h3></div></div></div> +<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">Align</span><span class="special">></span> +<span class="keyword">struct</span> <span class="identifier">type_with_alignment</span> +<span class="special">{</span> + <span class="keyword">typedef</span> <em class="replaceable"><code>see-below</code></em> <span class="identifier">type</span><span class="special">;</span> +<span class="special">};</span> +</pre> +<p> + <span class="bold"><strong>type:</strong></span> a built-in or POD type with an alignment + that is a multiple of <code class="computeroutput"><span class="identifier">Align</span></code>. + </p> +<p> + <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"> <span class="preprocessor">#include</span> + <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">type_with_alignment</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> + </p> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="remove_volatile.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="../history.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/boost_typetraits/user_defined.html b/libs/type_traits/doc/html/boost_typetraits/user_defined.html new file mode 100644 index 0000000000..843029f26a --- /dev/null +++ b/libs/type_traits/doc/html/boost_typetraits/user_defined.html @@ -0,0 +1,81 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>User Defined Specializations</title> +<link rel="stylesheet" href="../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="prev" href="category/function.html" title="Decomposing Function Types"> +<link rel="next" href="intrinsics.html" title="Support for Compiler Intrinsics"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../boost.png"></td> +<td align="center"><a href="../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="category/function.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="intrinsics.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h2 class="title" style="clear: both"> +<a name="boost_typetraits.user_defined"></a><a class="link" href="user_defined.html" title="User Defined Specializations">User Defined Specializations</a> +</h2></div></div></div> +<p> + 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::<a class="link" href="reference/integral_constant.html" title="integral_constant">true_type</a> + or boost::<a class="link" href="reference/integral_constant.html" title="integral_constant">false_type</a> + as appropriate: + </p> +<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">is_pod</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span> +<span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">is_class</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span> +<span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">is_union</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span> + +<span class="keyword">struct</span> <span class="identifier">my_pod</span><span class="special">{};</span> +<span class="keyword">struct</span> <span class="identifier">my_union</span> +<span class="special">{</span> + <span class="keyword">char</span> <span class="identifier">c</span><span class="special">;</span> + <span class="keyword">int</span> <span class="identifier">i</span><span class="special">;</span> +<span class="special">};</span> + +<span class="keyword">namespace</span> <span class="identifier">boost</span> +<span class="special">{</span> + <span class="keyword">template</span><span class="special"><></span> + <span class="keyword">struct</span> <a class="link" href="reference/is_pod.html" title="is_pod">is_pod</a><span class="special"><</span><span class="identifier">my_pod</span><span class="special">></span> <span class="special">:</span> <span class="keyword">public</span> <a class="link" href="reference/integral_constant.html" title="integral_constant">true_type</a><span class="special">{};</span> + + <span class="keyword">template</span><span class="special"><></span> + <span class="keyword">struct</span> <a class="link" href="reference/is_pod.html" title="is_pod">is_pod</a><span class="special"><</span><span class="identifier">my_union</span><span class="special">></span> <span class="special">:</span> <span class="keyword">public</span> <a class="link" href="reference/integral_constant.html" title="integral_constant">true_type</a><span class="special">{};</span> + + <span class="keyword">template</span><span class="special"><></span> + <span class="keyword">struct</span> <a class="link" href="reference/is_union.html" title="is_union">is_union</a><span class="special"><</span><span class="identifier">my_union</span><span class="special">></span> <span class="special">:</span> <span class="keyword">public</span> <a class="link" href="reference/integral_constant.html" title="integral_constant">true_type</a><span class="special">{};</span> + + <span class="keyword">template</span><span class="special"><></span> + <span class="keyword">struct</span> <a class="link" href="reference/is_class.html" title="is_class">is_class</a><span class="special"><</span><span class="identifier">my_union</span><span class="special">></span> <span class="special">:</span> <span class="keyword">public</span> <a class="link" href="reference/integral_constant.html" title="integral_constant">false_type</a><span class="special">{};</span> +<span class="special">}</span> +</pre> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="category/function.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="intrinsics.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/index.html b/libs/type_traits/doc/html/index.html new file mode 100644 index 0000000000..87d3803d35 --- /dev/null +++ b/libs/type_traits/doc/html/index.html @@ -0,0 +1,221 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>Chapter 1. Boost.TypeTraits</title> +<link rel="stylesheet" href="../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="next" href="boost_typetraits/intro.html" title="Introduction"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../boost.png"></td> +<td align="center"><a href="../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"><a accesskey="n" href="boost_typetraits/intro.html"><img src="../../../../doc/src/images/next.png" alt="Next"></a></div> +<div class="chapter"> +<div class="titlepage"><div> +<div><h2 class="title"> +<a name="boost_typetraits"></a>Chapter 1. Boost.TypeTraits</h2></div> +<div><div class="author"><h3 class="author"> +<span class="firstname">various</span> <span class="surname">authors</span> +</h3></div></div> +<div><p class="copyright">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe</p></div> +<div><div class="legalnotice"> +<a name="id3246830"></a><p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></div> +</div></div> +<div class="toc"> +<p><b>Table of Contents</b></p> +<dl> +<dt><span class="section"><a href="boost_typetraits/intro.html">Introduction</a></span></dt> +<dt><span class="section"><a href="boost_typetraits/background.html">Background and Tutorial</a></span></dt> +<dt><span class="section"><a href="boost_typetraits/category.html">Type Traits by Category</a></span></dt> +<dd><dl> +<dt><span class="section"><a href="boost_typetraits/category/value_traits.html">Type Traits that + Describe the Properties of a Type</a></span></dt> +<dd><dl> +<dt><span class="section"><a href="boost_typetraits/category/value_traits/primary.html">Categorizing + a Type</a></span></dt> +<dt><span class="section"><a href="boost_typetraits/category/value_traits/properties.html">General + Type Properties</a></span></dt> +<dt><span class="section"><a href="boost_typetraits/category/value_traits/relate.html">Relationships + Between Two Types</a></span></dt> +<dt><span class="section"><a href="boost_typetraits/category/value_traits/operators.html">Operator + Type Traits</a></span></dt> +</dl></dd> +<dt><span class="section"><a href="boost_typetraits/category/transform.html">Type Traits that + Transform One Type to Another</a></span></dt> +<dt><span class="section"><a href="boost_typetraits/category/alignment.html">Synthesizing Types + with Specific Alignments</a></span></dt> +<dt><span class="section"><a href="boost_typetraits/category/function.html">Decomposing Function + Types</a></span></dt> +</dl></dd> +<dt><span class="section"><a href="boost_typetraits/user_defined.html">User Defined Specializations</a></span></dt> +<dt><span class="section"><a href="boost_typetraits/intrinsics.html">Support for Compiler Intrinsics</a></span></dt> +<dt><span class="section"><a href="boost_typetraits/mpl.html">MPL Interoperability</a></span></dt> +<dt><span class="section"><a href="boost_typetraits/examples.html">Examples</a></span></dt> +<dd><dl> +<dt><span class="section"><a href="boost_typetraits/examples/copy.html">An Optimized Version + of std::copy</a></span></dt> +<dt><span class="section"><a href="boost_typetraits/examples/fill.html">An Optimised Version + of std::fill</a></span></dt> +<dt><span class="section"><a href="boost_typetraits/examples/destruct.html">An Example that Omits + Destructor Calls For Types with Trivial Destructors</a></span></dt> +<dt><span class="section"><a href="boost_typetraits/examples/iter.html">An improved Version of + std::iter_swap</a></span></dt> +<dt><span class="section"><a href="boost_typetraits/examples/to_double.html">Convert Numeric + Types and Enums to double</a></span></dt> +<dt><span class="section"><a href="boost_typetraits/examples/improved_min.html">Improving std::min + with common_type</a></span></dt> +</dl></dd> +<dt><span class="section"><a href="boost_typetraits/reference.html">Alphabetical Reference</a></span></dt> +<dd><dl> +<dt><span class="section"><a href="boost_typetraits/reference/add_const.html">add_const</a></span></dt> +<dt><span class="section"><a href="boost_typetraits/reference/add_cv.html">add_cv</a></span></dt> +<dt><span class="section"><a href="boost_typetraits/reference/add_lvalue_reference.html">add_lvalue_reference</a></span></dt> +<dt><span class="section"><a href="boost_typetraits/reference/add_pointer.html">add_pointer</a></span></dt> +<dt><span class="section"><a href="boost_typetraits/reference/add_reference.html">add_reference</a></span></dt> +<dt><span class="section"><a href="boost_typetraits/reference/add_rvalue_reference.html">add_rvalue_reference</a></span></dt> +<dt><span class="section"><a href="boost_typetraits/reference/add_volatile.html">add_volatile</a></span></dt> +<dt><span class="section"><a href="boost_typetraits/reference/aligned_storage.html">aligned_storage</a></span></dt> +<dt><span class="section"><a href="boost_typetraits/reference/alignment_of.html">alignment_of</a></span></dt> +<dt><span class="section"><a href="boost_typetraits/reference/conditional.html">conditional</a></span></dt> +<dt><span class="section"><a href="boost_typetraits/reference/common_type.html">common_type</a></span></dt> +<dt><span class="section"><a href="boost_typetraits/reference/decay.html">decay</a></span></dt> +<dt><span class="section"><a href="boost_typetraits/reference/extent.html">extent</a></span></dt> +<dt><span class="section"><a href="boost_typetraits/reference/floating_point_promotion.html">floating_point_promotion</a></span></dt> +<dt><span class="section"><a href="boost_typetraits/reference/function_traits.html">function_traits</a></span></dt> +<dt><span class="section"><a href="boost_typetraits/reference/has_bit_and.html">has_bit_and</a></span></dt> +<dt><span class="section"><a href="boost_typetraits/reference/has_bit_and_assign.html">has_bit_and_assign</a></span></dt> +<dt><span class="section"><a href="boost_typetraits/reference/has_bit_or.html">has_bit_or</a></span></dt> +<dt><span class="section"><a href="boost_typetraits/reference/has_bit_or_assign.html">has_bit_or_assign</a></span></dt> +<dt><span class="section"><a href="boost_typetraits/reference/has_bit_xor.html">has_bit_xor</a></span></dt> +<dt><span class="section"><a href="boost_typetraits/reference/has_bit_xor_assign.html">has_bit_xor_assign</a></span></dt> +<dt><span class="section"><a href="boost_typetraits/reference/has_complement.html">has_complement</a></span></dt> +<dt><span class="section"><a href="boost_typetraits/reference/has_dereference.html">has_dereference</a></span></dt> +<dt><span class="section"><a href="boost_typetraits/reference/has_divides.html">has_divides</a></span></dt> +<dt><span class="section"><a href="boost_typetraits/reference/has_divides_assign.html">has_divides_assign</a></span></dt> +<dt><span class="section"><a href="boost_typetraits/reference/has_equal_to.html">has_equal_to</a></span></dt> +<dt><span class="section"><a href="boost_typetraits/reference/has_greater.html">has_greater</a></span></dt> +<dt><span class="section"><a href="boost_typetraits/reference/has_greater_equal.html">has_greater_equal</a></span></dt> +<dt><span class="section"><a href="boost_typetraits/reference/has_left_shift.html">has_left_shift</a></span></dt> +<dt><span class="section"><a href="boost_typetraits/reference/has_left_shift_assign.html">has_left_shift_assign</a></span></dt> +<dt><span class="section"><a href="boost_typetraits/reference/has_less.html">has_less</a></span></dt> +<dt><span class="section"><a href="boost_typetraits/reference/has_less_equal.html">has_less_equal</a></span></dt> +<dt><span class="section"><a href="boost_typetraits/reference/has_logical_and.html">has_logical_and</a></span></dt> +<dt><span class="section"><a href="boost_typetraits/reference/has_logical_not.html">has_logical_not</a></span></dt> +<dt><span class="section"><a href="boost_typetraits/reference/has_logical_or.html">has_logical_or</a></span></dt> +<dt><span class="section"><a href="boost_typetraits/reference/has_minus.html">has_minus</a></span></dt> +<dt><span class="section"><a href="boost_typetraits/reference/has_minus_assign.html">has_minus_assign</a></span></dt> +<dt><span class="section"><a href="boost_typetraits/reference/has_modulus.html">has_modulus</a></span></dt> +<dt><span class="section"><a href="boost_typetraits/reference/has_modulus_assign.html">has_modulus_assign</a></span></dt> +<dt><span class="section"><a href="boost_typetraits/reference/has_multiplies.html">has_multiplies</a></span></dt> +<dt><span class="section"><a href="boost_typetraits/reference/has_multiplies_assign.html">has_multiplies_assign</a></span></dt> +<dt><span class="section"><a href="boost_typetraits/reference/has_negate.html">has_negate</a></span></dt> +<dt><span class="section"><a href="boost_typetraits/reference/has_new_operator.html">has_new_operator</a></span></dt> +<dt><span class="section"><a href="boost_typetraits/reference/has_not_equal_to.html">has_not_equal_to</a></span></dt> +<dt><span class="section"><a href="boost_typetraits/reference/has_nothrow_assign.html">has_nothrow_assign</a></span></dt> +<dt><span class="section"><a href="boost_typetraits/reference/has_nothrow_constructor.html">has_nothrow_constructor</a></span></dt> +<dt><span class="section"><a href="boost_typetraits/reference/has_nothrow_copy.html">has_nothrow_copy</a></span></dt> +<dt><span class="section"><a href="boost_typetraits/reference/has_nothrow_cp_cons.html">has_nothrow_copy_constructor</a></span></dt> +<dt><span class="section"><a href="boost_typetraits/reference/has_no_throw_def_cons.html">has_nothrow_default_constructor</a></span></dt> +<dt><span class="section"><a href="boost_typetraits/reference/has_plus.html">has_plus</a></span></dt> +<dt><span class="section"><a href="boost_typetraits/reference/has_plus_assign.html">has_plus_assign</a></span></dt> +<dt><span class="section"><a href="boost_typetraits/reference/has_post_decrement.html">has_post_decrement</a></span></dt> +<dt><span class="section"><a href="boost_typetraits/reference/has_post_increment.html">has_post_increment</a></span></dt> +<dt><span class="section"><a href="boost_typetraits/reference/has_pre_decrement.html">has_pre_decrement</a></span></dt> +<dt><span class="section"><a href="boost_typetraits/reference/has_pre_increment.html">has_pre_increment</a></span></dt> +<dt><span class="section"><a href="boost_typetraits/reference/has_right_shift.html">has_right_shift</a></span></dt> +<dt><span class="section"><a href="boost_typetraits/reference/has_right_shift_assign.html">has_right_shift_assign</a></span></dt> +<dt><span class="section"><a href="boost_typetraits/reference/has_trivial_assign.html">has_trivial_assign</a></span></dt> +<dt><span class="section"><a href="boost_typetraits/reference/has_trivial_constructor.html">has_trivial_constructor</a></span></dt> +<dt><span class="section"><a href="boost_typetraits/reference/has_trivial_copy.html">has_trivial_copy</a></span></dt> +<dt><span class="section"><a href="boost_typetraits/reference/has_trivial_cp_cons.html">has_trivial_copy_constructor</a></span></dt> +<dt><span class="section"><a href="boost_typetraits/reference/has_trivial_def_cons.html">has_trivial_default_constructor</a></span></dt> +<dt><span class="section"><a href="boost_typetraits/reference/has_trivial_destructor.html">has_trivial_destructor</a></span></dt> +<dt><span class="section"><a href="boost_typetraits/reference/has_unary_minus.html">has_unary_minus</a></span></dt> +<dt><span class="section"><a href="boost_typetraits/reference/has_unary_plus.html">has_unary_plus</a></span></dt> +<dt><span class="section"><a href="boost_typetraits/reference/has_virtual_destructor.html">has_virtual_destructor</a></span></dt> +<dt><span class="section"><a href="boost_typetraits/reference/integral_constant.html">integral_constant</a></span></dt> +<dt><span class="section"><a href="boost_typetraits/reference/integral_promotion.html">integral_promotion</a></span></dt> +<dt><span class="section"><a href="boost_typetraits/reference/is_abstract.html">is_abstract</a></span></dt> +<dt><span class="section"><a href="boost_typetraits/reference/is_arithmetic.html">is_arithmetic</a></span></dt> +<dt><span class="section"><a href="boost_typetraits/reference/is_array.html">is_array</a></span></dt> +<dt><span class="section"><a href="boost_typetraits/reference/is_base_of.html">is_base_of</a></span></dt> +<dt><span class="section"><a href="boost_typetraits/reference/is_class.html">is_class</a></span></dt> +<dt><span class="section"><a href="boost_typetraits/reference/is_complex.html">is_complex</a></span></dt> +<dt><span class="section"><a href="boost_typetraits/reference/is_compound.html">is_compound</a></span></dt> +<dt><span class="section"><a href="boost_typetraits/reference/is_const.html">is_const</a></span></dt> +<dt><span class="section"><a href="boost_typetraits/reference/is_convertible.html">is_convertible</a></span></dt> +<dt><span class="section"><a href="boost_typetraits/reference/is_empty.html">is_empty</a></span></dt> +<dt><span class="section"><a href="boost_typetraits/reference/is_enum.html">is_enum</a></span></dt> +<dt><span class="section"><a href="boost_typetraits/reference/is_floating_point.html">is_floating_point</a></span></dt> +<dt><span class="section"><a href="boost_typetraits/reference/is_function.html">is_function</a></span></dt> +<dt><span class="section"><a href="boost_typetraits/reference/is_fundamental.html">is_fundamental</a></span></dt> +<dt><span class="section"><a href="boost_typetraits/reference/is_integral.html">is_integral</a></span></dt> +<dt><span class="section"><a href="boost_typetraits/reference/is_lvalue_reference.html">is_lvalue_reference</a></span></dt> +<dt><span class="section"><a href="boost_typetraits/reference/is_member_function_pointer.html">is_member_function_pointer</a></span></dt> +<dt><span class="section"><a href="boost_typetraits/reference/is_member_object_pointer.html">is_member_object_pointer</a></span></dt> +<dt><span class="section"><a href="boost_typetraits/reference/is_member_pointer.html">is_member_pointer</a></span></dt> +<dt><span class="section"><a href="boost_typetraits/reference/is_object.html">is_object</a></span></dt> +<dt><span class="section"><a href="boost_typetraits/reference/is_pod.html">is_pod</a></span></dt> +<dt><span class="section"><a href="boost_typetraits/reference/is_pointer.html">is_pointer</a></span></dt> +<dt><span class="section"><a href="boost_typetraits/reference/is_polymorphic.html">is_polymorphic</a></span></dt> +<dt><span class="section"><a href="boost_typetraits/reference/is_reference.html">is_reference</a></span></dt> +<dt><span class="section"><a href="boost_typetraits/reference/is_rvalue_reference.html">is_rvalue_reference</a></span></dt> +<dt><span class="section"><a href="boost_typetraits/reference/is_same.html">is_same</a></span></dt> +<dt><span class="section"><a href="boost_typetraits/reference/is_scalar.html">is_scalar</a></span></dt> +<dt><span class="section"><a href="boost_typetraits/reference/is_signed.html">is_signed</a></span></dt> +<dt><span class="section"><a href="boost_typetraits/reference/is_stateless.html">is_stateless</a></span></dt> +<dt><span class="section"><a href="boost_typetraits/reference/is_union.html">is_union</a></span></dt> +<dt><span class="section"><a href="boost_typetraits/reference/is_unsigned.html">is_unsigned</a></span></dt> +<dt><span class="section"><a href="boost_typetraits/reference/is_virtual_base_of.html">is_virtual_base_of</a></span></dt> +<dt><span class="section"><a href="boost_typetraits/reference/is_void.html">is_void</a></span></dt> +<dt><span class="section"><a href="boost_typetraits/reference/is_volatile.html">is_volatile</a></span></dt> +<dt><span class="section"><a href="boost_typetraits/reference/make_signed.html">make_signed</a></span></dt> +<dt><span class="section"><a href="boost_typetraits/reference/make_unsigned.html">make_unsigned</a></span></dt> +<dt><span class="section"><a href="boost_typetraits/reference/promote.html">promote</a></span></dt> +<dt><span class="section"><a href="boost_typetraits/reference/rank.html">rank</a></span></dt> +<dt><span class="section"><a href="boost_typetraits/reference/remove_all_extents.html">remove_all_extents</a></span></dt> +<dt><span class="section"><a href="boost_typetraits/reference/remove_const.html">remove_const</a></span></dt> +<dt><span class="section"><a href="boost_typetraits/reference/remove_cv.html">remove_cv</a></span></dt> +<dt><span class="section"><a href="boost_typetraits/reference/remove_extent.html">remove_extent</a></span></dt> +<dt><span class="section"><a href="boost_typetraits/reference/remove_pointer.html">remove_pointer</a></span></dt> +<dt><span class="section"><a href="boost_typetraits/reference/remove_reference.html">remove_reference</a></span></dt> +<dt><span class="section"><a href="boost_typetraits/reference/remove_volatile.html">remove_volatile</a></span></dt> +<dt><span class="section"><a href="boost_typetraits/reference/type_with_alignment.html">type_with_alignment</a></span></dt> +</dl></dd> +<dt><span class="section"><a href="boost_typetraits/history.html">History</a></span></dt> +<dt><span class="section"><a href="boost_typetraits/credits.html">Credits</a></span></dt> +<dt><span class="section"><a href="index/s11.html">Class Index</a></span></dt> +<dt><span class="section"><a href="index/s12.html">Typedef Index</a></span></dt> +<dt><span class="section"><a href="index/s13.html">Macro Index</a></span></dt> +<dt><span class="section"><a href="index/s14.html">Index</a></span></dt> +</dl> +</div> +<p> + A printer-friendly <a href="http://sourceforge.net/projects/boost/files/boost-docs/" target="_top">PDF + version of this manual is also available</a>. + </p> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"><p><small>Last revised: October 07, 2011 at 23:05:54 +0200</small></p></td> +<td align="right"><div class="copyright-footer"></div></td> +</tr></table> +<hr> +<div class="spirit-nav"><a accesskey="n" href="boost_typetraits/intro.html"><img src="../../../../doc/src/images/next.png" alt="Next"></a></div> +</body> +</html> diff --git a/libs/type_traits/doc/html/index/s11.html b/libs/type_traits/doc/html/index/s11.html new file mode 100644 index 0000000000..685ba2b685 --- /dev/null +++ b/libs/type_traits/doc/html/index/s11.html @@ -0,0 +1,418 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>Class Index</title> +<link rel="stylesheet" href="../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="prev" href="../boost_typetraits/credits.html" title="Credits"> +<link rel="next" href="s12.html" title="Typedef Index"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../boost.png"></td> +<td align="center"><a href="../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="../boost_typetraits/credits.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="s12.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h2 class="title" style="clear: both"> +<a name="id3424769"></a>Class Index</h2></div></div></div> +<p><a class="link" href="s11.html#idx_id_0">A</a> <a class="link" href="s11.html#idx_id_2">C</a> <a class="link" href="s11.html#idx_id_3">D</a> <a class="link" href="s11.html#idx_id_4">E</a> <a class="link" href="s11.html#idx_id_5">F</a> <a class="link" href="s11.html#idx_id_6">H</a> <a class="link" href="s11.html#idx_id_7">I</a> <a class="link" href="s11.html#idx_id_8">M</a> <a class="link" href="s11.html#idx_id_9">N</a> <a class="link" href="s11.html#idx_id_10">O</a> <a class="link" href="s11.html#idx_id_11">P</a> <a class="link" href="s11.html#idx_id_12">R</a> <a class="link" href="s11.html#idx_id_13">T</a></p> +<div class="variablelist"><dl> +<dt> +<a name="idx_id_0"></a><span class="term">A</span> +</dt> +<dd><div class="index"><ul class="index" type="none" compact> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/add_const.html" title="add_const"><span class="index-entry-level-0">add_const</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/add_cv.html" title="add_cv"><span class="index-entry-level-0">add_cv</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/add_lvalue_reference.html" title="add_lvalue_reference"><span class="index-entry-level-0">add_lvalue_reference</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/add_pointer.html" title="add_pointer"><span class="index-entry-level-0">add_pointer</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/add_reference.html" title="add_reference"><span class="index-entry-level-0">add_reference</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/add_rvalue_reference.html" title="add_rvalue_reference"><span class="index-entry-level-0">add_rvalue_reference</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/add_volatile.html" title="add_volatile"><span class="index-entry-level-0">add_volatile</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/aligned_storage.html" title="aligned_storage"><span class="index-entry-level-0">aligned_storage</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/alignment_of.html" title="alignment_of"><span class="index-entry-level-0">alignment_of</span></a></p></li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">any</span></p> +<div class="index"><ul class="index" type="none" compact><li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/category/value_traits/operators.html" title="Operator Type Traits"><span class="index-entry-level-1">Operator Type Traits</span></a></p></li></ul></div> +</li> +</ul></div></dd> +<dt> +<a name="idx_id_2"></a><span class="term">C</span> +</dt> +<dd><div class="index"><ul class="index" type="none" compact><li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">common_type</span></p> +<div class="index"><ul class="index" type="none" compact> +<li class="listitem" style="list-style-type: none"><p><span class="bold"><strong><a class="link" href="../boost_typetraits/reference/common_type.html" title="common_type"><span class="index-entry-level-1">common_type</span></a></strong></span></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/examples/improved_min.html" title="Improving std::min with common_type"><span class="index-entry-level-1">Improving std::min with common_type</span></a></p></li> +</ul></div> +</li></ul></div></dd> +<dt> +<a name="idx_id_3"></a><span class="term">D</span> +</dt> +<dd><div class="index"><ul class="index" type="none" compact> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/decay.html" title="decay"><span class="index-entry-level-0">decay</span></a></p></li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">dont_care</span></p> +<div class="index"><ul class="index" type="none" compact> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_bit_and.html" title="has_bit_and"><span class="index-entry-level-1">has_bit_and</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_bit_and_assign.html" title="has_bit_and_assign"><span class="index-entry-level-1">has_bit_and_assign</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_bit_or.html" title="has_bit_or"><span class="index-entry-level-1">has_bit_or</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_bit_or_assign.html" title="has_bit_or_assign"><span class="index-entry-level-1">has_bit_or_assign</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_bit_xor.html" title="has_bit_xor"><span class="index-entry-level-1">has_bit_xor</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_bit_xor_assign.html" title="has_bit_xor_assign"><span class="index-entry-level-1">has_bit_xor_assign</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_complement.html" title="has_complement"><span class="index-entry-level-1">has_complement</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_dereference.html" title="has_dereference"><span class="index-entry-level-1">has_dereference</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_divides.html" title="has_divides"><span class="index-entry-level-1">has_divides</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_divides_assign.html" title="has_divides_assign"><span class="index-entry-level-1">has_divides_assign</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_equal_to.html" title="has_equal_to"><span class="index-entry-level-1">has_equal_to</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_greater.html" title="has_greater"><span class="index-entry-level-1">has_greater</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_greater_equal.html" title="has_greater_equal"><span class="index-entry-level-1">has_greater_equal</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_left_shift.html" title="has_left_shift"><span class="index-entry-level-1">has_left_shift</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_left_shift_assign.html" title="has_left_shift_assign"><span class="index-entry-level-1">has_left_shift_assign</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_less.html" title="has_less"><span class="index-entry-level-1">has_less</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_less_equal.html" title="has_less_equal"><span class="index-entry-level-1">has_less_equal</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_logical_and.html" title="has_logical_and"><span class="index-entry-level-1">has_logical_and</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_logical_not.html" title="has_logical_not"><span class="index-entry-level-1">has_logical_not</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_logical_or.html" title="has_logical_or"><span class="index-entry-level-1">has_logical_or</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_minus.html" title="has_minus"><span class="index-entry-level-1">has_minus</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_minus_assign.html" title="has_minus_assign"><span class="index-entry-level-1">has_minus_assign</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_modulus.html" title="has_modulus"><span class="index-entry-level-1">has_modulus</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_modulus_assign.html" title="has_modulus_assign"><span class="index-entry-level-1">has_modulus_assign</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_multiplies.html" title="has_multiplies"><span class="index-entry-level-1">has_multiplies</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_multiplies_assign.html" title="has_multiplies_assign"><span class="index-entry-level-1">has_multiplies_assign</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_negate.html" title="has_negate"><span class="index-entry-level-1">has_negate</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_not_equal_to.html" title="has_not_equal_to"><span class="index-entry-level-1">has_not_equal_to</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_plus.html" title="has_plus"><span class="index-entry-level-1">has_plus</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_plus_assign.html" title="has_plus_assign"><span class="index-entry-level-1">has_plus_assign</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_post_decrement.html" title="has_post_decrement"><span class="index-entry-level-1">has_post_decrement</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_post_increment.html" title="has_post_increment"><span class="index-entry-level-1">has_post_increment</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_pre_decrement.html" title="has_pre_decrement"><span class="index-entry-level-1">has_pre_decrement</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_pre_increment.html" title="has_pre_increment"><span class="index-entry-level-1">has_pre_increment</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_right_shift.html" title="has_right_shift"><span class="index-entry-level-1">has_right_shift</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_right_shift_assign.html" title="has_right_shift_assign"><span class="index-entry-level-1">has_right_shift_assign</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_unary_minus.html" title="has_unary_minus"><span class="index-entry-level-1">has_unary_minus</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_unary_plus.html" title="has_unary_plus"><span class="index-entry-level-1">has_unary_plus</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/category/value_traits/operators.html" title="Operator Type Traits"><span class="index-entry-level-1">Operator Type Traits</span></a></p></li> +</ul></div> +</li> +</ul></div></dd> +<dt> +<a name="idx_id_4"></a><span class="term">E</span> +</dt> +<dd><div class="index"><ul class="index" type="none" compact><li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/extent.html" title="extent"><span class="index-entry-level-0">extent</span></a></p></li></ul></div></dd> +<dt> +<a name="idx_id_5"></a><span class="term">F</span> +</dt> +<dd><div class="index"><ul class="index" type="none" compact> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/floating_point_promotion.html" title="floating_point_promotion"><span class="index-entry-level-0">floating_point_promotion</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/function_traits.html" title="function_traits"><span class="index-entry-level-0">function_traits</span></a></p></li> +</ul></div></dd> +<dt> +<a name="idx_id_6"></a><span class="term">H</span> +</dt> +<dd><div class="index"><ul class="index" type="none" compact> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_bit_and.html" title="has_bit_and"><span class="index-entry-level-0">has_bit_and</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_bit_and_assign.html" title="has_bit_and_assign"><span class="index-entry-level-0">has_bit_and_assign</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_bit_or.html" title="has_bit_or"><span class="index-entry-level-0">has_bit_or</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_bit_or_assign.html" title="has_bit_or_assign"><span class="index-entry-level-0">has_bit_or_assign</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_bit_xor.html" title="has_bit_xor"><span class="index-entry-level-0">has_bit_xor</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_bit_xor_assign.html" title="has_bit_xor_assign"><span class="index-entry-level-0">has_bit_xor_assign</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_complement.html" title="has_complement"><span class="index-entry-level-0">has_complement</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_dereference.html" title="has_dereference"><span class="index-entry-level-0">has_dereference</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_divides.html" title="has_divides"><span class="index-entry-level-0">has_divides</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_divides_assign.html" title="has_divides_assign"><span class="index-entry-level-0">has_divides_assign</span></a></p></li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">has_equal_to</span></p> +<div class="index"><ul class="index" type="none" compact> +<li class="listitem" style="list-style-type: none"><p><span class="bold"><strong><a class="link" href="../boost_typetraits/reference/has_equal_to.html" title="has_equal_to"><span class="index-entry-level-1">has_equal_to</span></a></strong></span></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/category/value_traits/operators.html" title="Operator Type Traits"><span class="index-entry-level-1">Operator Type Traits</span></a></p></li> +</ul></div> +</li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_greater.html" title="has_greater"><span class="index-entry-level-0">has_greater</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_greater_equal.html" title="has_greater_equal"><span class="index-entry-level-0">has_greater_equal</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_left_shift.html" title="has_left_shift"><span class="index-entry-level-0">has_left_shift</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_left_shift_assign.html" title="has_left_shift_assign"><span class="index-entry-level-0">has_left_shift_assign</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_less.html" title="has_less"><span class="index-entry-level-0">has_less</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_less_equal.html" title="has_less_equal"><span class="index-entry-level-0">has_less_equal</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_logical_and.html" title="has_logical_and"><span class="index-entry-level-0">has_logical_and</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_logical_not.html" title="has_logical_not"><span class="index-entry-level-0">has_logical_not</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_logical_or.html" title="has_logical_or"><span class="index-entry-level-0">has_logical_or</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_minus.html" title="has_minus"><span class="index-entry-level-0">has_minus</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_minus_assign.html" title="has_minus_assign"><span class="index-entry-level-0">has_minus_assign</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_modulus.html" title="has_modulus"><span class="index-entry-level-0">has_modulus</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_modulus_assign.html" title="has_modulus_assign"><span class="index-entry-level-0">has_modulus_assign</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_multiplies.html" title="has_multiplies"><span class="index-entry-level-0">has_multiplies</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_multiplies_assign.html" title="has_multiplies_assign"><span class="index-entry-level-0">has_multiplies_assign</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_negate.html" title="has_negate"><span class="index-entry-level-0">has_negate</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_new_operator.html" title="has_new_operator"><span class="index-entry-level-0">has_new_operator</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_nothrow_assign.html" title="has_nothrow_assign"><span class="index-entry-level-0">has_nothrow_assign</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_nothrow_constructor.html" title="has_nothrow_constructor"><span class="index-entry-level-0">has_nothrow_constructor</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_nothrow_copy.html" title="has_nothrow_copy"><span class="index-entry-level-0">has_nothrow_copy</span></a></p></li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">has_nothrow_copy_constructor</span></p> +<div class="index"><ul class="index" type="none" compact><li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_nothrow_copy.html" title="has_nothrow_copy"><span class="index-entry-level-1">has_nothrow_copy</span></a></p></li></ul></div> +</li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">has_nothrow_default_constructor</span></p> +<div class="index"><ul class="index" type="none" compact><li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_nothrow_constructor.html" title="has_nothrow_constructor"><span class="index-entry-level-1">has_nothrow_constructor</span></a></p></li></ul></div> +</li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_not_equal_to.html" title="has_not_equal_to"><span class="index-entry-level-0">has_not_equal_to</span></a></p></li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">has_operator</span></p> +<div class="index"><ul class="index" type="none" compact><li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/category/value_traits/operators.html" title="Operator Type Traits"><span class="index-entry-level-1">Operator Type Traits</span></a></p></li></ul></div> +</li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_plus.html" title="has_plus"><span class="index-entry-level-0">has_plus</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_plus_assign.html" title="has_plus_assign"><span class="index-entry-level-0">has_plus_assign</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_post_decrement.html" title="has_post_decrement"><span class="index-entry-level-0">has_post_decrement</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_post_increment.html" title="has_post_increment"><span class="index-entry-level-0">has_post_increment</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_pre_decrement.html" title="has_pre_decrement"><span class="index-entry-level-0">has_pre_decrement</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_pre_increment.html" title="has_pre_increment"><span class="index-entry-level-0">has_pre_increment</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_right_shift.html" title="has_right_shift"><span class="index-entry-level-0">has_right_shift</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_right_shift_assign.html" title="has_right_shift_assign"><span class="index-entry-level-0">has_right_shift_assign</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_trivial_assign.html" title="has_trivial_assign"><span class="index-entry-level-0">has_trivial_assign</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_trivial_constructor.html" title="has_trivial_constructor"><span class="index-entry-level-0">has_trivial_constructor</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_trivial_copy.html" title="has_trivial_copy"><span class="index-entry-level-0">has_trivial_copy</span></a></p></li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">has_trivial_copy_constructor</span></p> +<div class="index"><ul class="index" type="none" compact><li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_trivial_copy.html" title="has_trivial_copy"><span class="index-entry-level-1">has_trivial_copy</span></a></p></li></ul></div> +</li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">has_trivial_default_constructor</span></p> +<div class="index"><ul class="index" type="none" compact><li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_trivial_constructor.html" title="has_trivial_constructor"><span class="index-entry-level-1">has_trivial_constructor</span></a></p></li></ul></div> +</li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_trivial_destructor.html" title="has_trivial_destructor"><span class="index-entry-level-0">has_trivial_destructor</span></a></p></li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">has_unary_minus</span></p> +<div class="index"><ul class="index" type="none" compact> +<li class="listitem" style="list-style-type: none"><p><span class="bold"><strong><a class="link" href="../boost_typetraits/reference/has_unary_minus.html" title="has_unary_minus"><span class="index-entry-level-1">has_unary_minus</span></a></strong></span></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/category/value_traits/operators.html" title="Operator Type Traits"><span class="index-entry-level-1">Operator Type Traits</span></a></p></li> +</ul></div> +</li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_unary_plus.html" title="has_unary_plus"><span class="index-entry-level-0">has_unary_plus</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_virtual_destructor.html" title="has_virtual_destructor"><span class="index-entry-level-0">has_virtual_destructor</span></a></p></li> +</ul></div></dd> +<dt> +<a name="idx_id_7"></a><span class="term">I</span> +</dt> +<dd><div class="index"><ul class="index" type="none" compact> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">integral_constant</span></p> +<div class="index"><ul class="index" type="none" compact> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/alignment_of.html" title="alignment_of"><span class="index-entry-level-1">alignment_of</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/extent.html" title="extent"><span class="index-entry-level-1">extent</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><span class="bold"><strong><a class="link" href="../boost_typetraits/reference/integral_constant.html" title="integral_constant"><span class="index-entry-level-1">integral_constant</span></a></strong></span></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/category/value_traits/operators.html" title="Operator Type Traits"><span class="index-entry-level-1">Operator Type Traits</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/rank.html" title="rank"><span class="index-entry-level-1">rank</span></a></p></li> +</ul></div> +</li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/integral_promotion.html" title="integral_promotion"><span class="index-entry-level-0">integral_promotion</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/is_abstract.html" title="is_abstract"><span class="index-entry-level-0">is_abstract</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/is_arithmetic.html" title="is_arithmetic"><span class="index-entry-level-0">is_arithmetic</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/is_array.html" title="is_array"><span class="index-entry-level-0">is_array</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/is_base_of.html" title="is_base_of"><span class="index-entry-level-0">is_base_of</span></a></p></li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">is_class</span></p> +<div class="index"><ul class="index" type="none" compact> +<li class="listitem" style="list-style-type: none"><p><span class="bold"><strong><a class="link" href="../boost_typetraits/reference/is_class.html" title="is_class"><span class="index-entry-level-1">is_class</span></a></strong></span></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/user_defined.html" title="User Defined Specializations"><span class="index-entry-level-1">User Defined Specializations</span></a></p></li> +</ul></div> +</li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/is_complex.html" title="is_complex"><span class="index-entry-level-0">is_complex</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/is_compound.html" title="is_compound"><span class="index-entry-level-0">is_compound</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/is_const.html" title="is_const"><span class="index-entry-level-0">is_const</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/is_convertible.html" title="is_convertible"><span class="index-entry-level-0">is_convertible</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/is_empty.html" title="is_empty"><span class="index-entry-level-0">is_empty</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/is_enum.html" title="is_enum"><span class="index-entry-level-0">is_enum</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/is_floating_point.html" title="is_floating_point"><span class="index-entry-level-0">is_floating_point</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/is_function.html" title="is_function"><span class="index-entry-level-0">is_function</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/is_fundamental.html" title="is_fundamental"><span class="index-entry-level-0">is_fundamental</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/is_integral.html" title="is_integral"><span class="index-entry-level-0">is_integral</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/is_lvalue_reference.html" title="is_lvalue_reference"><span class="index-entry-level-0">is_lvalue_reference</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/is_member_function_pointer.html" title="is_member_function_pointer"><span class="index-entry-level-0">is_member_function_pointer</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/is_member_object_pointer.html" title="is_member_object_pointer"><span class="index-entry-level-0">is_member_object_pointer</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/is_member_pointer.html" title="is_member_pointer"><span class="index-entry-level-0">is_member_pointer</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/is_object.html" title="is_object"><span class="index-entry-level-0">is_object</span></a></p></li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">is_pod</span></p> +<div class="index"><ul class="index" type="none" compact> +<li class="listitem" style="list-style-type: none"><p><span class="bold"><strong><a class="link" href="../boost_typetraits/reference/is_pod.html" title="is_pod"><span class="index-entry-level-1">is_pod</span></a></strong></span></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/user_defined.html" title="User Defined Specializations"><span class="index-entry-level-1">User Defined Specializations</span></a></p></li> +</ul></div> +</li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">is_pointer</span></p> +<div class="index"><ul class="index" type="none" compact> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/background.html" title="Background and Tutorial"><span class="index-entry-level-1">Background and Tutorial</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><span class="bold"><strong><a class="link" href="../boost_typetraits/reference/is_pointer.html" title="is_pointer"><span class="index-entry-level-1">is_pointer</span></a></strong></span></p></li> +</ul></div> +</li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/is_polymorphic.html" title="is_polymorphic"><span class="index-entry-level-0">is_polymorphic</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/is_reference.html" title="is_reference"><span class="index-entry-level-0">is_reference</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/is_rvalue_reference.html" title="is_rvalue_reference"><span class="index-entry-level-0">is_rvalue_reference</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/is_same.html" title="is_same"><span class="index-entry-level-0">is_same</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/is_scalar.html" title="is_scalar"><span class="index-entry-level-0">is_scalar</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/is_signed.html" title="is_signed"><span class="index-entry-level-0">is_signed</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/is_stateless.html" title="is_stateless"><span class="index-entry-level-0">is_stateless</span></a></p></li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">is_union</span></p> +<div class="index"><ul class="index" type="none" compact> +<li class="listitem" style="list-style-type: none"><p><span class="bold"><strong><a class="link" href="../boost_typetraits/reference/is_union.html" title="is_union"><span class="index-entry-level-1">is_union</span></a></strong></span></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/user_defined.html" title="User Defined Specializations"><span class="index-entry-level-1">User Defined Specializations</span></a></p></li> +</ul></div> +</li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/is_unsigned.html" title="is_unsigned"><span class="index-entry-level-0">is_unsigned</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/is_virtual_base_of.html" title="is_virtual_base_of"><span class="index-entry-level-0">is_virtual_base_of</span></a></p></li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">is_void</span></p> +<div class="index"><ul class="index" type="none" compact> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/background.html" title="Background and Tutorial"><span class="index-entry-level-1">Background and Tutorial</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><span class="bold"><strong><a class="link" href="../boost_typetraits/reference/is_void.html" title="is_void"><span class="index-entry-level-1">is_void</span></a></strong></span></p></li> +</ul></div> +</li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/is_volatile.html" title="is_volatile"><span class="index-entry-level-0">is_volatile</span></a></p></li> +</ul></div></dd> +<dt> +<a name="idx_id_8"></a><span class="term">M</span> +</dt> +<dd><div class="index"><ul class="index" type="none" compact> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/make_signed.html" title="make_signed"><span class="index-entry-level-0">make_signed</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/make_unsigned.html" title="make_unsigned"><span class="index-entry-level-0">make_unsigned</span></a></p></li> +</ul></div></dd> +<dt> +<a name="idx_id_9"></a><span class="term">N</span> +</dt> +<dd><div class="index"><ul class="index" type="none" compact><li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">no_operator</span></p> +<div class="index"><ul class="index" type="none" compact><li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/category/value_traits/operators.html" title="Operator Type Traits"><span class="index-entry-level-1">Operator Type Traits</span></a></p></li></ul></div> +</li></ul></div></dd> +<dt> +<a name="idx_id_10"></a><span class="term">O</span> +</dt> +<dd><div class="index"><ul class="index" type="none" compact> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">operator_exists</span></p> +<div class="index"><ul class="index" type="none" compact><li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/category/value_traits/operators.html" title="Operator Type Traits"><span class="index-entry-level-1">Operator Type Traits</span></a></p></li></ul></div> +</li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">operator_returns_Ret</span></p> +<div class="index"><ul class="index" type="none" compact><li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/category/value_traits/operators.html" title="Operator Type Traits"><span class="index-entry-level-1">Operator Type Traits</span></a></p></li></ul></div> +</li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">operator_returns_void</span></p> +<div class="index"><ul class="index" type="none" compact><li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/category/value_traits/operators.html" title="Operator Type Traits"><span class="index-entry-level-1">Operator Type Traits</span></a></p></li></ul></div> +</li> +</ul></div></dd> +<dt> +<a name="idx_id_11"></a><span class="term">P</span> +</dt> +<dd><div class="index"><ul class="index" type="none" compact><li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/promote.html" title="promote"><span class="index-entry-level-0">promote</span></a></p></li></ul></div></dd> +<dt> +<a name="idx_id_12"></a><span class="term">R</span> +</dt> +<dd><div class="index"><ul class="index" type="none" compact> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/rank.html" title="rank"><span class="index-entry-level-0">rank</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/remove_all_extents.html" title="remove_all_extents"><span class="index-entry-level-0">remove_all_extents</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/remove_const.html" title="remove_const"><span class="index-entry-level-0">remove_const</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/remove_cv.html" title="remove_cv"><span class="index-entry-level-0">remove_cv</span></a></p></li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">remove_extent</span></p> +<div class="index"><ul class="index" type="none" compact> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/background.html" title="Background and Tutorial"><span class="index-entry-level-1">Background and Tutorial</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><span class="bold"><strong><a class="link" href="../boost_typetraits/reference/remove_extent.html" title="remove_extent"><span class="index-entry-level-1">remove_extent</span></a></strong></span></p></li> +</ul></div> +</li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/remove_pointer.html" title="remove_pointer"><span class="index-entry-level-0">remove_pointer</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/remove_reference.html" title="remove_reference"><span class="index-entry-level-0">remove_reference</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/remove_volatile.html" title="remove_volatile"><span class="index-entry-level-0">remove_volatile</span></a></p></li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">returns_void_t</span></p> +<div class="index"><ul class="index" type="none" compact><li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/category/value_traits/operators.html" title="Operator Type Traits"><span class="index-entry-level-1">Operator Type Traits</span></a></p></li></ul></div> +</li> +</ul></div></dd> +<dt> +<a name="idx_id_13"></a><span class="term">T</span> +</dt> +<dd><div class="index"><ul class="index" type="none" compact> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">trait</span></p> +<div class="index"><ul class="index" type="none" compact> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_bit_and.html" title="has_bit_and"><span class="index-entry-level-1">has_bit_and</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_bit_and_assign.html" title="has_bit_and_assign"><span class="index-entry-level-1">has_bit_and_assign</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_bit_or.html" title="has_bit_or"><span class="index-entry-level-1">has_bit_or</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_bit_or_assign.html" title="has_bit_or_assign"><span class="index-entry-level-1">has_bit_or_assign</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_bit_xor.html" title="has_bit_xor"><span class="index-entry-level-1">has_bit_xor</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_bit_xor_assign.html" title="has_bit_xor_assign"><span class="index-entry-level-1">has_bit_xor_assign</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_complement.html" title="has_complement"><span class="index-entry-level-1">has_complement</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_dereference.html" title="has_dereference"><span class="index-entry-level-1">has_dereference</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_divides.html" title="has_divides"><span class="index-entry-level-1">has_divides</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_divides_assign.html" title="has_divides_assign"><span class="index-entry-level-1">has_divides_assign</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_equal_to.html" title="has_equal_to"><span class="index-entry-level-1">has_equal_to</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_greater.html" title="has_greater"><span class="index-entry-level-1">has_greater</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_greater_equal.html" title="has_greater_equal"><span class="index-entry-level-1">has_greater_equal</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_left_shift.html" title="has_left_shift"><span class="index-entry-level-1">has_left_shift</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_left_shift_assign.html" title="has_left_shift_assign"><span class="index-entry-level-1">has_left_shift_assign</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_less.html" title="has_less"><span class="index-entry-level-1">has_less</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_less_equal.html" title="has_less_equal"><span class="index-entry-level-1">has_less_equal</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_logical_and.html" title="has_logical_and"><span class="index-entry-level-1">has_logical_and</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_logical_not.html" title="has_logical_not"><span class="index-entry-level-1">has_logical_not</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_logical_or.html" title="has_logical_or"><span class="index-entry-level-1">has_logical_or</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_minus.html" title="has_minus"><span class="index-entry-level-1">has_minus</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_minus_assign.html" title="has_minus_assign"><span class="index-entry-level-1">has_minus_assign</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_modulus.html" title="has_modulus"><span class="index-entry-level-1">has_modulus</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_modulus_assign.html" title="has_modulus_assign"><span class="index-entry-level-1">has_modulus_assign</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_multiplies.html" title="has_multiplies"><span class="index-entry-level-1">has_multiplies</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_multiplies_assign.html" title="has_multiplies_assign"><span class="index-entry-level-1">has_multiplies_assign</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_negate.html" title="has_negate"><span class="index-entry-level-1">has_negate</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_not_equal_to.html" title="has_not_equal_to"><span class="index-entry-level-1">has_not_equal_to</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_plus.html" title="has_plus"><span class="index-entry-level-1">has_plus</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_plus_assign.html" title="has_plus_assign"><span class="index-entry-level-1">has_plus_assign</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_post_decrement.html" title="has_post_decrement"><span class="index-entry-level-1">has_post_decrement</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_post_increment.html" title="has_post_increment"><span class="index-entry-level-1">has_post_increment</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_pre_decrement.html" title="has_pre_decrement"><span class="index-entry-level-1">has_pre_decrement</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_pre_increment.html" title="has_pre_increment"><span class="index-entry-level-1">has_pre_increment</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_right_shift.html" title="has_right_shift"><span class="index-entry-level-1">has_right_shift</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_right_shift_assign.html" title="has_right_shift_assign"><span class="index-entry-level-1">has_right_shift_assign</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_unary_minus.html" title="has_unary_minus"><span class="index-entry-level-1">has_unary_minus</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_unary_plus.html" title="has_unary_plus"><span class="index-entry-level-1">has_unary_plus</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/category/value_traits/operators.html" title="Operator Type Traits"><span class="index-entry-level-1">Operator Type Traits</span></a></p></li> +</ul></div> +</li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">trait_impl</span></p> +<div class="index"><ul class="index" type="none" compact><li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/category/value_traits/operators.html" title="Operator Type Traits"><span class="index-entry-level-1">Operator Type Traits</span></a></p></li></ul></div> +</li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">trait_impl1</span></p> +<div class="index"><ul class="index" type="none" compact><li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/category/value_traits/operators.html" title="Operator Type Traits"><span class="index-entry-level-1">Operator Type Traits</span></a></p></li></ul></div> +</li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/type_with_alignment.html" title="type_with_alignment"><span class="index-entry-level-0">type_with_alignment</span></a></p></li> +</ul></div></dd> +</dl></div> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="../boost_typetraits/credits.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="s12.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/index/s12.html b/libs/type_traits/doc/html/index/s12.html new file mode 100644 index 0000000000..c5d4ee7f90 --- /dev/null +++ b/libs/type_traits/doc/html/index/s12.html @@ -0,0 +1,84 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>Typedef Index</title> +<link rel="stylesheet" href="../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="prev" href="s11.html" title="Class Index"> +<link rel="next" href="s13.html" title="Macro Index"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../boost.png"></td> +<td align="center"><a href="../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="s11.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="s13.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h2 class="title" style="clear: both"> +<a name="id3428131"></a>Typedef Index</h2></div></div></div> +<p><a class="link" href="s12.html#idx_id_20">F</a> <a class="link" href="s12.html#idx_id_27">R</a> <a class="link" href="s12.html#idx_id_28">T</a></p> +<div class="variablelist"><dl> +<dt> +<a name="idx_id_20"></a><span class="term">F</span> +</dt> +<dd><div class="index"><ul class="index" type="none" compact><li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">false_type</span></p> +<div class="index"><ul class="index" type="none" compact><li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/integral_constant.html" title="integral_constant"><span class="index-entry-level-1">integral_constant</span></a></p></li></ul></div> +</li></ul></div></dd> +<dt> +<a name="idx_id_27"></a><span class="term">R</span> +</dt> +<dd><div class="index"><ul class="index" type="none" compact> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">result_type</span></p> +<div class="index"><ul class="index" type="none" compact><li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/function_traits.html" title="function_traits"><span class="index-entry-level-1">function_traits</span></a></p></li></ul></div> +</li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">Rhs_nocv</span></p> +<div class="index"><ul class="index" type="none" compact><li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/category/value_traits/operators.html" title="Operator Type Traits"><span class="index-entry-level-1">Operator Type Traits</span></a></p></li></ul></div> +</li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">Rhs_noptr</span></p> +<div class="index"><ul class="index" type="none" compact><li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/category/value_traits/operators.html" title="Operator Type Traits"><span class="index-entry-level-1">Operator Type Traits</span></a></p></li></ul></div> +</li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">Rhs_noref</span></p> +<div class="index"><ul class="index" type="none" compact><li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/category/value_traits/operators.html" title="Operator Type Traits"><span class="index-entry-level-1">Operator Type Traits</span></a></p></li></ul></div> +</li> +</ul></div></dd> +<dt> +<a name="idx_id_28"></a><span class="term">T</span> +</dt> +<dd><div class="index"><ul class="index" type="none" compact><li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">true_type</span></p> +<div class="index"><ul class="index" type="none" compact><li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/integral_constant.html" title="integral_constant"><span class="index-entry-level-1">integral_constant</span></a></p></li></ul></div> +</li></ul></div></dd> +</dl></div> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="s11.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="s13.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/index/s13.html b/libs/type_traits/doc/html/index/s13.html new file mode 100644 index 0000000000..431b2ce698 --- /dev/null +++ b/libs/type_traits/doc/html/index/s13.html @@ -0,0 +1,167 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>Macro Index</title> +<link rel="stylesheet" href="../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="prev" href="s12.html" title="Typedef Index"> +<link rel="next" href="s14.html" title="Index"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../boost.png"></td> +<td align="center"><a href="../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="s12.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="s14.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h2 class="title" style="clear: both"> +<a name="id3428370"></a>Macro Index</h2></div></div></div> +<p><a class="link" href="s13.html#idx_id_31">B</a></p> +<div class="variablelist"><dl> +<dt> +<a name="idx_id_31"></a><span class="term">B</span> +</dt> +<dd><div class="index"><ul class="index" type="none" compact> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">BOOST_ALIGNMENT_OF</span></p> +<div class="index"><ul class="index" type="none" compact><li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/intrinsics.html#boost_typetraits.intrinsics.macros_for_compiler_intrinsics" title="Table 1.9. Macros for Compiler Intrinsics"><span class="index-entry-level-1">Macros for Compiler Intrinsics</span></a></p></li></ul></div> +</li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION</span></p> +<div class="index"><ul class="index" type="none" compact><li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/category/transform.html" title="Type Traits that Transform One Type to Another"><span class="index-entry-level-1">Type Traits that Transform One Type to Another</span></a></p></li></ul></div> +</li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">BOOST_COMMON_TYPE_DONT_USE_TYPEOF</span></p> +<div class="index"><ul class="index" type="none" compact><li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/common_type.html" title="common_type"><span class="index-entry-level-1">common_type</span></a></p></li></ul></div> +</li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">BOOST_HAS_NOTHROW_ASSIGN</span></p> +<div class="index"><ul class="index" type="none" compact><li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/intrinsics.html#boost_typetraits.intrinsics.macros_for_compiler_intrinsics" title="Table 1.9. Macros for Compiler Intrinsics"><span class="index-entry-level-1">Macros for Compiler Intrinsics</span></a></p></li></ul></div> +</li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">BOOST_HAS_NOTHROW_CONSTRUCTOR</span></p> +<div class="index"><ul class="index" type="none" compact> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_nothrow_constructor.html" title="has_nothrow_constructor"><span class="index-entry-level-1">has_nothrow_constructor</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/intrinsics.html#boost_typetraits.intrinsics.macros_for_compiler_intrinsics" title="Table 1.9. Macros for Compiler Intrinsics"><span class="index-entry-level-1">Macros for Compiler Intrinsics</span></a></p></li> +</ul></div> +</li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">BOOST_HAS_NOTHROW_COPY</span></p> +<div class="index"><ul class="index" type="none" compact> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_nothrow_copy.html" title="has_nothrow_copy"><span class="index-entry-level-1">has_nothrow_copy</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/intrinsics.html#boost_typetraits.intrinsics.macros_for_compiler_intrinsics" title="Table 1.9. Macros for Compiler Intrinsics"><span class="index-entry-level-1">Macros for Compiler Intrinsics</span></a></p></li> +</ul></div> +</li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">BOOST_HAS_TRIVIAL_ASSIGN</span></p> +<div class="index"><ul class="index" type="none" compact> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_trivial_assign.html" title="has_trivial_assign"><span class="index-entry-level-1">has_trivial_assign</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/intrinsics.html#boost_typetraits.intrinsics.macros_for_compiler_intrinsics" title="Table 1.9. Macros for Compiler Intrinsics"><span class="index-entry-level-1">Macros for Compiler Intrinsics</span></a></p></li> +</ul></div> +</li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">BOOST_HAS_TRIVIAL_CONSTRUCTOR</span></p> +<div class="index"><ul class="index" type="none" compact> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_trivial_constructor.html" title="has_trivial_constructor"><span class="index-entry-level-1">has_trivial_constructor</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/intrinsics.html#boost_typetraits.intrinsics.macros_for_compiler_intrinsics" title="Table 1.9. Macros for Compiler Intrinsics"><span class="index-entry-level-1">Macros for Compiler Intrinsics</span></a></p></li> +</ul></div> +</li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">BOOST_HAS_TRIVIAL_COPY</span></p> +<div class="index"><ul class="index" type="none" compact> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_trivial_copy.html" title="has_trivial_copy"><span class="index-entry-level-1">has_trivial_copy</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/intrinsics.html#boost_typetraits.intrinsics.macros_for_compiler_intrinsics" title="Table 1.9. Macros for Compiler Intrinsics"><span class="index-entry-level-1">Macros for Compiler Intrinsics</span></a></p></li> +</ul></div> +</li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">BOOST_HAS_TRIVIAL_DESTRUCTOR</span></p> +<div class="index"><ul class="index" type="none" compact> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_trivial_destructor.html" title="has_trivial_destructor"><span class="index-entry-level-1">has_trivial_destructor</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/intrinsics.html#boost_typetraits.intrinsics.macros_for_compiler_intrinsics" title="Table 1.9. Macros for Compiler Intrinsics"><span class="index-entry-level-1">Macros for Compiler Intrinsics</span></a></p></li> +</ul></div> +</li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">BOOST_HAS_VIRTUAL_DESTRUCTOR</span></p> +<div class="index"><ul class="index" type="none" compact> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_virtual_destructor.html" title="has_virtual_destructor"><span class="index-entry-level-1">has_virtual_destructor</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/intrinsics.html#boost_typetraits.intrinsics.macros_for_compiler_intrinsics" title="Table 1.9. Macros for Compiler Intrinsics"><span class="index-entry-level-1">Macros for Compiler Intrinsics</span></a></p></li> +</ul></div> +</li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">BOOST_IS_ABSTRACT</span></p> +<div class="index"><ul class="index" type="none" compact><li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/intrinsics.html#boost_typetraits.intrinsics.macros_for_compiler_intrinsics" title="Table 1.9. Macros for Compiler Intrinsics"><span class="index-entry-level-1">Macros for Compiler Intrinsics</span></a></p></li></ul></div> +</li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">BOOST_IS_BASE_OF</span></p> +<div class="index"><ul class="index" type="none" compact><li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/intrinsics.html#boost_typetraits.intrinsics.macros_for_compiler_intrinsics" title="Table 1.9. Macros for Compiler Intrinsics"><span class="index-entry-level-1">Macros for Compiler Intrinsics</span></a></p></li></ul></div> +</li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">BOOST_IS_CLASS</span></p> +<div class="index"><ul class="index" type="none" compact> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/is_class.html" title="is_class"><span class="index-entry-level-1">is_class</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/intrinsics.html#boost_typetraits.intrinsics.macros_for_compiler_intrinsics" title="Table 1.9. Macros for Compiler Intrinsics"><span class="index-entry-level-1">Macros for Compiler Intrinsics</span></a></p></li> +</ul></div> +</li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">BOOST_IS_CONVERTIBLE</span></p> +<div class="index"><ul class="index" type="none" compact><li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/intrinsics.html#boost_typetraits.intrinsics.macros_for_compiler_intrinsics" title="Table 1.9. Macros for Compiler Intrinsics"><span class="index-entry-level-1">Macros for Compiler Intrinsics</span></a></p></li></ul></div> +</li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">BOOST_IS_EMPTY</span></p> +<div class="index"><ul class="index" type="none" compact> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/is_empty.html" title="is_empty"><span class="index-entry-level-1">is_empty</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/intrinsics.html#boost_typetraits.intrinsics.macros_for_compiler_intrinsics" title="Table 1.9. Macros for Compiler Intrinsics"><span class="index-entry-level-1">Macros for Compiler Intrinsics</span></a></p></li> +</ul></div> +</li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">BOOST_IS_ENUM</span></p> +<div class="index"><ul class="index" type="none" compact><li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/intrinsics.html#boost_typetraits.intrinsics.macros_for_compiler_intrinsics" title="Table 1.9. Macros for Compiler Intrinsics"><span class="index-entry-level-1">Macros for Compiler Intrinsics</span></a></p></li></ul></div> +</li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">BOOST_IS_POD</span></p> +<div class="index"><ul class="index" type="none" compact> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/is_pod.html" title="is_pod"><span class="index-entry-level-1">is_pod</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/intrinsics.html#boost_typetraits.intrinsics.macros_for_compiler_intrinsics" title="Table 1.9. Macros for Compiler Intrinsics"><span class="index-entry-level-1">Macros for Compiler Intrinsics</span></a></p></li> +</ul></div> +</li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">BOOST_IS_POLYMORPHIC</span></p> +<div class="index"><ul class="index" type="none" compact><li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/intrinsics.html#boost_typetraits.intrinsics.macros_for_compiler_intrinsics" title="Table 1.9. Macros for Compiler Intrinsics"><span class="index-entry-level-1">Macros for Compiler Intrinsics</span></a></p></li></ul></div> +</li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">BOOST_IS_UNION</span></p> +<div class="index"><ul class="index" type="none" compact> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/is_union.html" title="is_union"><span class="index-entry-level-1">is_union</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/intrinsics.html#boost_typetraits.intrinsics.macros_for_compiler_intrinsics" title="Table 1.9. Macros for Compiler Intrinsics"><span class="index-entry-level-1">Macros for Compiler Intrinsics</span></a></p></li> +</ul></div> +</li> +</ul></div></dd> +</dl></div> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="s12.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="s14.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/html/index/s14.html b/libs/type_traits/doc/html/index/s14.html new file mode 100644 index 0000000000..b5a0eac01c --- /dev/null +++ b/libs/type_traits/doc/html/index/s14.html @@ -0,0 +1,996 @@ +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<title>Index</title> +<link rel="stylesheet" href="../../../../../doc/src/boostbook.css" type="text/css"> +<meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> +<link rel="home" href="../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="up" href="../index.html" title="Chapter 1. Boost.TypeTraits"> +<link rel="prev" href="s13.html" title="Macro Index"> +</head> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> +<table cellpadding="2" width="100%"><tr> +<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../boost.png"></td> +<td align="center"><a href="../../../../../index.html">Home</a></td> +<td align="center"><a href="../../../../../libs/libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> +<td align="center"><a href="../../../../../more/index.htm">More</a></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="s13.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a> +</div> +<div class="section"> +<div class="titlepage"><div><div><h2 class="title" style="clear: both"> +<a name="id3429100"></a>Index</h2></div></div></div> +<p><a class="link" href="s14.html#idx_id_45">A</a> <a class="link" href="s14.html#idx_id_46">B</a> <a class="link" href="s14.html#idx_id_47">C</a> <a class="link" href="s14.html#idx_id_48">D</a> <a class="link" href="s14.html#idx_id_49">E</a> <a class="link" href="s14.html#idx_id_50">F</a> <a class="link" href="s14.html#idx_id_51">H</a> <a class="link" href="s14.html#idx_id_52">I</a> <a class="link" href="s14.html#idx_id_53">M</a> <a class="link" href="s14.html#idx_id_54">N</a> <a class="link" href="s14.html#idx_id_55">O</a> <a class="link" href="s14.html#idx_id_56">P</a> <a class="link" href="s14.html#idx_id_57">R</a> <a class="link" href="s14.html#idx_id_58">T</a> <a class="link" href="s14.html#idx_id_59">U</a></p> +<div class="variablelist"><dl> +<dt> +<a name="idx_id_45"></a><span class="term">A</span> +</dt> +<dd><div class="index"><ul class="index" type="none" compact> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/add_const.html" title="add_const"><span class="index-entry-level-0">add_const</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/add_cv.html" title="add_cv"><span class="index-entry-level-0">add_cv</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/add_lvalue_reference.html" title="add_lvalue_reference"><span class="index-entry-level-0">add_lvalue_reference</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/add_pointer.html" title="add_pointer"><span class="index-entry-level-0">add_pointer</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/add_reference.html" title="add_reference"><span class="index-entry-level-0">add_reference</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/add_rvalue_reference.html" title="add_rvalue_reference"><span class="index-entry-level-0">add_rvalue_reference</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/add_volatile.html" title="add_volatile"><span class="index-entry-level-0">add_volatile</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/aligned_storage.html" title="aligned_storage"><span class="index-entry-level-0">aligned_storage</span></a></p></li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">alignment_of</span></p> +<div class="index"><ul class="index" type="none" compact> +<li class="listitem" style="list-style-type: none"><p><span class="bold"><strong><a class="link" href="../boost_typetraits/reference/alignment_of.html" title="alignment_of"><span class="index-entry-level-1">alignment_of</span></a></strong></span></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/alignment_of.html" title="alignment_of"><span class="index-entry-level-1">integral_constant</span></a></p></li> +</ul></div> +</li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">any</span></p> +<div class="index"><ul class="index" type="none" compact><li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/category/value_traits/operators.html" title="Operator Type Traits"><span class="index-entry-level-1">Operator Type Traits</span></a></p></li></ul></div> +</li> +</ul></div></dd> +<dt> +<a name="idx_id_46"></a><span class="term">B</span> +</dt> +<dd><div class="index"><ul class="index" type="none" compact> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">Background and Tutorial</span></p> +<div class="index"><ul class="index" type="none" compact> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/background.html" title="Background and Tutorial"><span class="index-entry-level-1">is_pointer</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/background.html" title="Background and Tutorial"><span class="index-entry-level-1">is_void</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/background.html" title="Background and Tutorial"><span class="index-entry-level-1">remove_extent</span></a></p></li> +</ul></div> +</li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">BOOST_ALIGNMENT_OF</span></p> +<div class="index"><ul class="index" type="none" compact><li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/intrinsics.html#boost_typetraits.intrinsics.macros_for_compiler_intrinsics" title="Table 1.9. Macros for Compiler Intrinsics"><span class="index-entry-level-1">Macros for Compiler Intrinsics</span></a></p></li></ul></div> +</li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION</span></p> +<div class="index"><ul class="index" type="none" compact><li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/category/transform.html" title="Type Traits that Transform One Type to Another"><span class="index-entry-level-1">Type Traits that Transform One Type to Another</span></a></p></li></ul></div> +</li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">BOOST_COMMON_TYPE_DONT_USE_TYPEOF</span></p> +<div class="index"><ul class="index" type="none" compact><li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/common_type.html" title="common_type"><span class="index-entry-level-1">common_type</span></a></p></li></ul></div> +</li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">BOOST_HAS_NOTHROW_ASSIGN</span></p> +<div class="index"><ul class="index" type="none" compact><li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/intrinsics.html#boost_typetraits.intrinsics.macros_for_compiler_intrinsics" title="Table 1.9. Macros for Compiler Intrinsics"><span class="index-entry-level-1">Macros for Compiler Intrinsics</span></a></p></li></ul></div> +</li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">BOOST_HAS_NOTHROW_CONSTRUCTOR</span></p> +<div class="index"><ul class="index" type="none" compact> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_nothrow_constructor.html" title="has_nothrow_constructor"><span class="index-entry-level-1">has_nothrow_constructor</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/intrinsics.html#boost_typetraits.intrinsics.macros_for_compiler_intrinsics" title="Table 1.9. Macros for Compiler Intrinsics"><span class="index-entry-level-1">Macros for Compiler Intrinsics</span></a></p></li> +</ul></div> +</li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">BOOST_HAS_NOTHROW_COPY</span></p> +<div class="index"><ul class="index" type="none" compact> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_nothrow_copy.html" title="has_nothrow_copy"><span class="index-entry-level-1">has_nothrow_copy</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/intrinsics.html#boost_typetraits.intrinsics.macros_for_compiler_intrinsics" title="Table 1.9. Macros for Compiler Intrinsics"><span class="index-entry-level-1">Macros for Compiler Intrinsics</span></a></p></li> +</ul></div> +</li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">BOOST_HAS_TRIVIAL_ASSIGN</span></p> +<div class="index"><ul class="index" type="none" compact> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_trivial_assign.html" title="has_trivial_assign"><span class="index-entry-level-1">has_trivial_assign</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/intrinsics.html#boost_typetraits.intrinsics.macros_for_compiler_intrinsics" title="Table 1.9. Macros for Compiler Intrinsics"><span class="index-entry-level-1">Macros for Compiler Intrinsics</span></a></p></li> +</ul></div> +</li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">BOOST_HAS_TRIVIAL_CONSTRUCTOR</span></p> +<div class="index"><ul class="index" type="none" compact> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_trivial_constructor.html" title="has_trivial_constructor"><span class="index-entry-level-1">has_trivial_constructor</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/intrinsics.html#boost_typetraits.intrinsics.macros_for_compiler_intrinsics" title="Table 1.9. Macros for Compiler Intrinsics"><span class="index-entry-level-1">Macros for Compiler Intrinsics</span></a></p></li> +</ul></div> +</li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">BOOST_HAS_TRIVIAL_COPY</span></p> +<div class="index"><ul class="index" type="none" compact> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_trivial_copy.html" title="has_trivial_copy"><span class="index-entry-level-1">has_trivial_copy</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/intrinsics.html#boost_typetraits.intrinsics.macros_for_compiler_intrinsics" title="Table 1.9. Macros for Compiler Intrinsics"><span class="index-entry-level-1">Macros for Compiler Intrinsics</span></a></p></li> +</ul></div> +</li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">BOOST_HAS_TRIVIAL_DESTRUCTOR</span></p> +<div class="index"><ul class="index" type="none" compact> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_trivial_destructor.html" title="has_trivial_destructor"><span class="index-entry-level-1">has_trivial_destructor</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/intrinsics.html#boost_typetraits.intrinsics.macros_for_compiler_intrinsics" title="Table 1.9. Macros for Compiler Intrinsics"><span class="index-entry-level-1">Macros for Compiler Intrinsics</span></a></p></li> +</ul></div> +</li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">BOOST_HAS_VIRTUAL_DESTRUCTOR</span></p> +<div class="index"><ul class="index" type="none" compact> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_virtual_destructor.html" title="has_virtual_destructor"><span class="index-entry-level-1">has_virtual_destructor</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/intrinsics.html#boost_typetraits.intrinsics.macros_for_compiler_intrinsics" title="Table 1.9. Macros for Compiler Intrinsics"><span class="index-entry-level-1">Macros for Compiler Intrinsics</span></a></p></li> +</ul></div> +</li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">BOOST_IS_ABSTRACT</span></p> +<div class="index"><ul class="index" type="none" compact><li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/intrinsics.html#boost_typetraits.intrinsics.macros_for_compiler_intrinsics" title="Table 1.9. Macros for Compiler Intrinsics"><span class="index-entry-level-1">Macros for Compiler Intrinsics</span></a></p></li></ul></div> +</li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">BOOST_IS_BASE_OF</span></p> +<div class="index"><ul class="index" type="none" compact><li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/intrinsics.html#boost_typetraits.intrinsics.macros_for_compiler_intrinsics" title="Table 1.9. Macros for Compiler Intrinsics"><span class="index-entry-level-1">Macros for Compiler Intrinsics</span></a></p></li></ul></div> +</li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">BOOST_IS_CLASS</span></p> +<div class="index"><ul class="index" type="none" compact> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/is_class.html" title="is_class"><span class="index-entry-level-1">is_class</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/intrinsics.html#boost_typetraits.intrinsics.macros_for_compiler_intrinsics" title="Table 1.9. Macros for Compiler Intrinsics"><span class="index-entry-level-1">Macros for Compiler Intrinsics</span></a></p></li> +</ul></div> +</li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">BOOST_IS_CONVERTIBLE</span></p> +<div class="index"><ul class="index" type="none" compact><li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/intrinsics.html#boost_typetraits.intrinsics.macros_for_compiler_intrinsics" title="Table 1.9. Macros for Compiler Intrinsics"><span class="index-entry-level-1">Macros for Compiler Intrinsics</span></a></p></li></ul></div> +</li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">BOOST_IS_EMPTY</span></p> +<div class="index"><ul class="index" type="none" compact> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/is_empty.html" title="is_empty"><span class="index-entry-level-1">is_empty</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/intrinsics.html#boost_typetraits.intrinsics.macros_for_compiler_intrinsics" title="Table 1.9. Macros for Compiler Intrinsics"><span class="index-entry-level-1">Macros for Compiler Intrinsics</span></a></p></li> +</ul></div> +</li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">BOOST_IS_ENUM</span></p> +<div class="index"><ul class="index" type="none" compact><li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/intrinsics.html#boost_typetraits.intrinsics.macros_for_compiler_intrinsics" title="Table 1.9. Macros for Compiler Intrinsics"><span class="index-entry-level-1">Macros for Compiler Intrinsics</span></a></p></li></ul></div> +</li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">BOOST_IS_POD</span></p> +<div class="index"><ul class="index" type="none" compact> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/is_pod.html" title="is_pod"><span class="index-entry-level-1">is_pod</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/intrinsics.html#boost_typetraits.intrinsics.macros_for_compiler_intrinsics" title="Table 1.9. Macros for Compiler Intrinsics"><span class="index-entry-level-1">Macros for Compiler Intrinsics</span></a></p></li> +</ul></div> +</li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">BOOST_IS_POLYMORPHIC</span></p> +<div class="index"><ul class="index" type="none" compact><li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/intrinsics.html#boost_typetraits.intrinsics.macros_for_compiler_intrinsics" title="Table 1.9. Macros for Compiler Intrinsics"><span class="index-entry-level-1">Macros for Compiler Intrinsics</span></a></p></li></ul></div> +</li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">BOOST_IS_UNION</span></p> +<div class="index"><ul class="index" type="none" compact> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/is_union.html" title="is_union"><span class="index-entry-level-1">is_union</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/intrinsics.html#boost_typetraits.intrinsics.macros_for_compiler_intrinsics" title="Table 1.9. Macros for Compiler Intrinsics"><span class="index-entry-level-1">Macros for Compiler Intrinsics</span></a></p></li> +</ul></div> +</li> +</ul></div></dd> +<dt> +<a name="idx_id_47"></a><span class="term">C</span> +</dt> +<dd><div class="index"><ul class="index" type="none" compact> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">check</span></p> +<div class="index"><ul class="index" type="none" compact><li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/category/value_traits/operators.html" title="Operator Type Traits"><span class="index-entry-level-1">Operator Type Traits</span></a></p></li></ul></div> +</li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">common_type</span></p> +<div class="index"><ul class="index" type="none" compact> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/common_type.html" title="common_type"><span class="index-entry-level-1">BOOST_COMMON_TYPE_DONT_USE_TYPEOF</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><span class="bold"><strong><a class="link" href="../boost_typetraits/reference/common_type.html" title="common_type"><span class="index-entry-level-1">common_type</span></a></strong></span></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/examples/improved_min.html" title="Improving std::min with common_type"><span class="index-entry-level-1">Improving std::min with common_type</span></a></p></li> +</ul></div> +</li> +</ul></div></dd> +<dt> +<a name="idx_id_48"></a><span class="term">D</span> +</dt> +<dd><div class="index"><ul class="index" type="none" compact> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/decay.html" title="decay"><span class="index-entry-level-0">decay</span></a></p></li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">dont_care</span></p> +<div class="index"><ul class="index" type="none" compact> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_bit_and.html" title="has_bit_and"><span class="index-entry-level-1">has_bit_and</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_bit_and_assign.html" title="has_bit_and_assign"><span class="index-entry-level-1">has_bit_and_assign</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_bit_or.html" title="has_bit_or"><span class="index-entry-level-1">has_bit_or</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_bit_or_assign.html" title="has_bit_or_assign"><span class="index-entry-level-1">has_bit_or_assign</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_bit_xor.html" title="has_bit_xor"><span class="index-entry-level-1">has_bit_xor</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_bit_xor_assign.html" title="has_bit_xor_assign"><span class="index-entry-level-1">has_bit_xor_assign</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_complement.html" title="has_complement"><span class="index-entry-level-1">has_complement</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_dereference.html" title="has_dereference"><span class="index-entry-level-1">has_dereference</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_divides.html" title="has_divides"><span class="index-entry-level-1">has_divides</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_divides_assign.html" title="has_divides_assign"><span class="index-entry-level-1">has_divides_assign</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_equal_to.html" title="has_equal_to"><span class="index-entry-level-1">has_equal_to</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_greater.html" title="has_greater"><span class="index-entry-level-1">has_greater</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_greater_equal.html" title="has_greater_equal"><span class="index-entry-level-1">has_greater_equal</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_left_shift.html" title="has_left_shift"><span class="index-entry-level-1">has_left_shift</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_left_shift_assign.html" title="has_left_shift_assign"><span class="index-entry-level-1">has_left_shift_assign</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_less.html" title="has_less"><span class="index-entry-level-1">has_less</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_less_equal.html" title="has_less_equal"><span class="index-entry-level-1">has_less_equal</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_logical_and.html" title="has_logical_and"><span class="index-entry-level-1">has_logical_and</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_logical_not.html" title="has_logical_not"><span class="index-entry-level-1">has_logical_not</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_logical_or.html" title="has_logical_or"><span class="index-entry-level-1">has_logical_or</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_minus.html" title="has_minus"><span class="index-entry-level-1">has_minus</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_minus_assign.html" title="has_minus_assign"><span class="index-entry-level-1">has_minus_assign</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_modulus.html" title="has_modulus"><span class="index-entry-level-1">has_modulus</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_modulus_assign.html" title="has_modulus_assign"><span class="index-entry-level-1">has_modulus_assign</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_multiplies.html" title="has_multiplies"><span class="index-entry-level-1">has_multiplies</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_multiplies_assign.html" title="has_multiplies_assign"><span class="index-entry-level-1">has_multiplies_assign</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_negate.html" title="has_negate"><span class="index-entry-level-1">has_negate</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_not_equal_to.html" title="has_not_equal_to"><span class="index-entry-level-1">has_not_equal_to</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_plus.html" title="has_plus"><span class="index-entry-level-1">has_plus</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_plus_assign.html" title="has_plus_assign"><span class="index-entry-level-1">has_plus_assign</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_post_decrement.html" title="has_post_decrement"><span class="index-entry-level-1">has_post_decrement</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_post_increment.html" title="has_post_increment"><span class="index-entry-level-1">has_post_increment</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_pre_decrement.html" title="has_pre_decrement"><span class="index-entry-level-1">has_pre_decrement</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_pre_increment.html" title="has_pre_increment"><span class="index-entry-level-1">has_pre_increment</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_right_shift.html" title="has_right_shift"><span class="index-entry-level-1">has_right_shift</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_right_shift_assign.html" title="has_right_shift_assign"><span class="index-entry-level-1">has_right_shift_assign</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_unary_minus.html" title="has_unary_minus"><span class="index-entry-level-1">has_unary_minus</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_unary_plus.html" title="has_unary_plus"><span class="index-entry-level-1">has_unary_plus</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/category/value_traits/operators.html" title="Operator Type Traits"><span class="index-entry-level-1">Operator Type Traits</span></a></p></li> +</ul></div> +</li> +</ul></div></dd> +<dt> +<a name="idx_id_49"></a><span class="term">E</span> +</dt> +<dd><div class="index"><ul class="index" type="none" compact><li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">extent</span></p> +<div class="index"><ul class="index" type="none" compact> +<li class="listitem" style="list-style-type: none"><p><span class="bold"><strong><a class="link" href="../boost_typetraits/reference/extent.html" title="extent"><span class="index-entry-level-1">extent</span></a></strong></span></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/extent.html" title="extent"><span class="index-entry-level-1">integral_constant</span></a></p></li> +</ul></div> +</li></ul></div></dd> +<dt> +<a name="idx_id_50"></a><span class="term">F</span> +</dt> +<dd><div class="index"><ul class="index" type="none" compact> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">false_type</span></p> +<div class="index"><ul class="index" type="none" compact><li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/integral_constant.html" title="integral_constant"><span class="index-entry-level-1">integral_constant</span></a></p></li></ul></div> +</li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/floating_point_promotion.html" title="floating_point_promotion"><span class="index-entry-level-0">floating_point_promotion</span></a></p></li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">function_traits</span></p> +<div class="index"><ul class="index" type="none" compact> +<li class="listitem" style="list-style-type: none"><p><span class="bold"><strong><a class="link" href="../boost_typetraits/reference/function_traits.html" title="function_traits"><span class="index-entry-level-1">function_traits</span></a></strong></span></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/function_traits.html" title="function_traits"><span class="index-entry-level-1">result_type</span></a></p></li> +</ul></div> +</li> +</ul></div></dd> +<dt> +<a name="idx_id_51"></a><span class="term">H</span> +</dt> +<dd><div class="index"><ul class="index" type="none" compact> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">has_bit_and</span></p> +<div class="index"><ul class="index" type="none" compact> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_bit_and.html" title="has_bit_and"><span class="index-entry-level-1">dont_care</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><span class="bold"><strong><a class="link" href="../boost_typetraits/reference/has_bit_and.html" title="has_bit_and"><span class="index-entry-level-1">has_bit_and</span></a></strong></span></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_bit_and.html" title="has_bit_and"><span class="index-entry-level-1">trait</span></a></p></li> +</ul></div> +</li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">has_bit_and_assign</span></p> +<div class="index"><ul class="index" type="none" compact> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_bit_and_assign.html" title="has_bit_and_assign"><span class="index-entry-level-1">dont_care</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><span class="bold"><strong><a class="link" href="../boost_typetraits/reference/has_bit_and_assign.html" title="has_bit_and_assign"><span class="index-entry-level-1">has_bit_and_assign</span></a></strong></span></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_bit_and_assign.html" title="has_bit_and_assign"><span class="index-entry-level-1">trait</span></a></p></li> +</ul></div> +</li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">has_bit_or</span></p> +<div class="index"><ul class="index" type="none" compact> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_bit_or.html" title="has_bit_or"><span class="index-entry-level-1">dont_care</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><span class="bold"><strong><a class="link" href="../boost_typetraits/reference/has_bit_or.html" title="has_bit_or"><span class="index-entry-level-1">has_bit_or</span></a></strong></span></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_bit_or.html" title="has_bit_or"><span class="index-entry-level-1">trait</span></a></p></li> +</ul></div> +</li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">has_bit_or_assign</span></p> +<div class="index"><ul class="index" type="none" compact> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_bit_or_assign.html" title="has_bit_or_assign"><span class="index-entry-level-1">dont_care</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><span class="bold"><strong><a class="link" href="../boost_typetraits/reference/has_bit_or_assign.html" title="has_bit_or_assign"><span class="index-entry-level-1">has_bit_or_assign</span></a></strong></span></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_bit_or_assign.html" title="has_bit_or_assign"><span class="index-entry-level-1">trait</span></a></p></li> +</ul></div> +</li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">has_bit_xor</span></p> +<div class="index"><ul class="index" type="none" compact> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_bit_xor.html" title="has_bit_xor"><span class="index-entry-level-1">dont_care</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><span class="bold"><strong><a class="link" href="../boost_typetraits/reference/has_bit_xor.html" title="has_bit_xor"><span class="index-entry-level-1">has_bit_xor</span></a></strong></span></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_bit_xor.html" title="has_bit_xor"><span class="index-entry-level-1">trait</span></a></p></li> +</ul></div> +</li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">has_bit_xor_assign</span></p> +<div class="index"><ul class="index" type="none" compact> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_bit_xor_assign.html" title="has_bit_xor_assign"><span class="index-entry-level-1">dont_care</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><span class="bold"><strong><a class="link" href="../boost_typetraits/reference/has_bit_xor_assign.html" title="has_bit_xor_assign"><span class="index-entry-level-1">has_bit_xor_assign</span></a></strong></span></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_bit_xor_assign.html" title="has_bit_xor_assign"><span class="index-entry-level-1">trait</span></a></p></li> +</ul></div> +</li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">has_complement</span></p> +<div class="index"><ul class="index" type="none" compact> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_complement.html" title="has_complement"><span class="index-entry-level-1">dont_care</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><span class="bold"><strong><a class="link" href="../boost_typetraits/reference/has_complement.html" title="has_complement"><span class="index-entry-level-1">has_complement</span></a></strong></span></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_complement.html" title="has_complement"><span class="index-entry-level-1">trait</span></a></p></li> +</ul></div> +</li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">has_dereference</span></p> +<div class="index"><ul class="index" type="none" compact> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_dereference.html" title="has_dereference"><span class="index-entry-level-1">dont_care</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><span class="bold"><strong><a class="link" href="../boost_typetraits/reference/has_dereference.html" title="has_dereference"><span class="index-entry-level-1">has_dereference</span></a></strong></span></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_dereference.html" title="has_dereference"><span class="index-entry-level-1">trait</span></a></p></li> +</ul></div> +</li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">has_divides</span></p> +<div class="index"><ul class="index" type="none" compact> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_divides.html" title="has_divides"><span class="index-entry-level-1">dont_care</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><span class="bold"><strong><a class="link" href="../boost_typetraits/reference/has_divides.html" title="has_divides"><span class="index-entry-level-1">has_divides</span></a></strong></span></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_divides.html" title="has_divides"><span class="index-entry-level-1">trait</span></a></p></li> +</ul></div> +</li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">has_divides_assign</span></p> +<div class="index"><ul class="index" type="none" compact> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_divides_assign.html" title="has_divides_assign"><span class="index-entry-level-1">dont_care</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><span class="bold"><strong><a class="link" href="../boost_typetraits/reference/has_divides_assign.html" title="has_divides_assign"><span class="index-entry-level-1">has_divides_assign</span></a></strong></span></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_divides_assign.html" title="has_divides_assign"><span class="index-entry-level-1">trait</span></a></p></li> +</ul></div> +</li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">has_equal_to</span></p> +<div class="index"><ul class="index" type="none" compact> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_equal_to.html" title="has_equal_to"><span class="index-entry-level-1">dont_care</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><span class="bold"><strong><a class="link" href="../boost_typetraits/reference/has_equal_to.html" title="has_equal_to"><span class="index-entry-level-1">has_equal_to</span></a></strong></span></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/category/value_traits/operators.html" title="Operator Type Traits"><span class="index-entry-level-1">Operator Type Traits</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_equal_to.html" title="has_equal_to"><span class="index-entry-level-1">trait</span></a></p></li> +</ul></div> +</li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">has_greater</span></p> +<div class="index"><ul class="index" type="none" compact> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_greater.html" title="has_greater"><span class="index-entry-level-1">dont_care</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><span class="bold"><strong><a class="link" href="../boost_typetraits/reference/has_greater.html" title="has_greater"><span class="index-entry-level-1">has_greater</span></a></strong></span></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_greater.html" title="has_greater"><span class="index-entry-level-1">trait</span></a></p></li> +</ul></div> +</li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">has_greater_equal</span></p> +<div class="index"><ul class="index" type="none" compact> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_greater_equal.html" title="has_greater_equal"><span class="index-entry-level-1">dont_care</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><span class="bold"><strong><a class="link" href="../boost_typetraits/reference/has_greater_equal.html" title="has_greater_equal"><span class="index-entry-level-1">has_greater_equal</span></a></strong></span></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_greater_equal.html" title="has_greater_equal"><span class="index-entry-level-1">trait</span></a></p></li> +</ul></div> +</li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">has_left_shift</span></p> +<div class="index"><ul class="index" type="none" compact> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_left_shift.html" title="has_left_shift"><span class="index-entry-level-1">dont_care</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><span class="bold"><strong><a class="link" href="../boost_typetraits/reference/has_left_shift.html" title="has_left_shift"><span class="index-entry-level-1">has_left_shift</span></a></strong></span></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_left_shift.html" title="has_left_shift"><span class="index-entry-level-1">trait</span></a></p></li> +</ul></div> +</li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">has_left_shift_assign</span></p> +<div class="index"><ul class="index" type="none" compact> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_left_shift_assign.html" title="has_left_shift_assign"><span class="index-entry-level-1">dont_care</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><span class="bold"><strong><a class="link" href="../boost_typetraits/reference/has_left_shift_assign.html" title="has_left_shift_assign"><span class="index-entry-level-1">has_left_shift_assign</span></a></strong></span></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_left_shift_assign.html" title="has_left_shift_assign"><span class="index-entry-level-1">trait</span></a></p></li> +</ul></div> +</li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">has_less</span></p> +<div class="index"><ul class="index" type="none" compact> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_less.html" title="has_less"><span class="index-entry-level-1">dont_care</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><span class="bold"><strong><a class="link" href="../boost_typetraits/reference/has_less.html" title="has_less"><span class="index-entry-level-1">has_less</span></a></strong></span></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_less.html" title="has_less"><span class="index-entry-level-1">trait</span></a></p></li> +</ul></div> +</li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">has_less_equal</span></p> +<div class="index"><ul class="index" type="none" compact> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_less_equal.html" title="has_less_equal"><span class="index-entry-level-1">dont_care</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><span class="bold"><strong><a class="link" href="../boost_typetraits/reference/has_less_equal.html" title="has_less_equal"><span class="index-entry-level-1">has_less_equal</span></a></strong></span></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_less_equal.html" title="has_less_equal"><span class="index-entry-level-1">trait</span></a></p></li> +</ul></div> +</li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">has_logical_and</span></p> +<div class="index"><ul class="index" type="none" compact> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_logical_and.html" title="has_logical_and"><span class="index-entry-level-1">dont_care</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><span class="bold"><strong><a class="link" href="../boost_typetraits/reference/has_logical_and.html" title="has_logical_and"><span class="index-entry-level-1">has_logical_and</span></a></strong></span></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_logical_and.html" title="has_logical_and"><span class="index-entry-level-1">trait</span></a></p></li> +</ul></div> +</li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">has_logical_not</span></p> +<div class="index"><ul class="index" type="none" compact> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_logical_not.html" title="has_logical_not"><span class="index-entry-level-1">dont_care</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><span class="bold"><strong><a class="link" href="../boost_typetraits/reference/has_logical_not.html" title="has_logical_not"><span class="index-entry-level-1">has_logical_not</span></a></strong></span></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_logical_not.html" title="has_logical_not"><span class="index-entry-level-1">trait</span></a></p></li> +</ul></div> +</li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">has_logical_or</span></p> +<div class="index"><ul class="index" type="none" compact> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_logical_or.html" title="has_logical_or"><span class="index-entry-level-1">dont_care</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><span class="bold"><strong><a class="link" href="../boost_typetraits/reference/has_logical_or.html" title="has_logical_or"><span class="index-entry-level-1">has_logical_or</span></a></strong></span></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_logical_or.html" title="has_logical_or"><span class="index-entry-level-1">trait</span></a></p></li> +</ul></div> +</li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">has_minus</span></p> +<div class="index"><ul class="index" type="none" compact> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_minus.html" title="has_minus"><span class="index-entry-level-1">dont_care</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><span class="bold"><strong><a class="link" href="../boost_typetraits/reference/has_minus.html" title="has_minus"><span class="index-entry-level-1">has_minus</span></a></strong></span></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_minus.html" title="has_minus"><span class="index-entry-level-1">trait</span></a></p></li> +</ul></div> +</li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">has_minus_assign</span></p> +<div class="index"><ul class="index" type="none" compact> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_minus_assign.html" title="has_minus_assign"><span class="index-entry-level-1">dont_care</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><span class="bold"><strong><a class="link" href="../boost_typetraits/reference/has_minus_assign.html" title="has_minus_assign"><span class="index-entry-level-1">has_minus_assign</span></a></strong></span></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_minus_assign.html" title="has_minus_assign"><span class="index-entry-level-1">trait</span></a></p></li> +</ul></div> +</li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">has_modulus</span></p> +<div class="index"><ul class="index" type="none" compact> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_modulus.html" title="has_modulus"><span class="index-entry-level-1">dont_care</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><span class="bold"><strong><a class="link" href="../boost_typetraits/reference/has_modulus.html" title="has_modulus"><span class="index-entry-level-1">has_modulus</span></a></strong></span></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_modulus.html" title="has_modulus"><span class="index-entry-level-1">trait</span></a></p></li> +</ul></div> +</li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">has_modulus_assign</span></p> +<div class="index"><ul class="index" type="none" compact> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_modulus_assign.html" title="has_modulus_assign"><span class="index-entry-level-1">dont_care</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><span class="bold"><strong><a class="link" href="../boost_typetraits/reference/has_modulus_assign.html" title="has_modulus_assign"><span class="index-entry-level-1">has_modulus_assign</span></a></strong></span></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_modulus_assign.html" title="has_modulus_assign"><span class="index-entry-level-1">trait</span></a></p></li> +</ul></div> +</li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">has_multiplies</span></p> +<div class="index"><ul class="index" type="none" compact> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_multiplies.html" title="has_multiplies"><span class="index-entry-level-1">dont_care</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><span class="bold"><strong><a class="link" href="../boost_typetraits/reference/has_multiplies.html" title="has_multiplies"><span class="index-entry-level-1">has_multiplies</span></a></strong></span></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_multiplies.html" title="has_multiplies"><span class="index-entry-level-1">trait</span></a></p></li> +</ul></div> +</li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">has_multiplies_assign</span></p> +<div class="index"><ul class="index" type="none" compact> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_multiplies_assign.html" title="has_multiplies_assign"><span class="index-entry-level-1">dont_care</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><span class="bold"><strong><a class="link" href="../boost_typetraits/reference/has_multiplies_assign.html" title="has_multiplies_assign"><span class="index-entry-level-1">has_multiplies_assign</span></a></strong></span></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_multiplies_assign.html" title="has_multiplies_assign"><span class="index-entry-level-1">trait</span></a></p></li> +</ul></div> +</li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">has_negate</span></p> +<div class="index"><ul class="index" type="none" compact> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_negate.html" title="has_negate"><span class="index-entry-level-1">dont_care</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><span class="bold"><strong><a class="link" href="../boost_typetraits/reference/has_negate.html" title="has_negate"><span class="index-entry-level-1">has_negate</span></a></strong></span></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_negate.html" title="has_negate"><span class="index-entry-level-1">trait</span></a></p></li> +</ul></div> +</li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_new_operator.html" title="has_new_operator"><span class="index-entry-level-0">has_new_operator</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_nothrow_assign.html" title="has_nothrow_assign"><span class="index-entry-level-0">has_nothrow_assign</span></a></p></li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">has_nothrow_constructor</span></p> +<div class="index"><ul class="index" type="none" compact> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_nothrow_constructor.html" title="has_nothrow_constructor"><span class="index-entry-level-1">BOOST_HAS_NOTHROW_CONSTRUCTOR</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><span class="bold"><strong><a class="link" href="../boost_typetraits/reference/has_nothrow_constructor.html" title="has_nothrow_constructor"><span class="index-entry-level-1">has_nothrow_constructor</span></a></strong></span></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_nothrow_constructor.html" title="has_nothrow_constructor"><span class="index-entry-level-1">has_nothrow_default_constructor</span></a></p></li> +</ul></div> +</li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">has_nothrow_copy</span></p> +<div class="index"><ul class="index" type="none" compact> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_nothrow_copy.html" title="has_nothrow_copy"><span class="index-entry-level-1">BOOST_HAS_NOTHROW_COPY</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><span class="bold"><strong><a class="link" href="../boost_typetraits/reference/has_nothrow_copy.html" title="has_nothrow_copy"><span class="index-entry-level-1">has_nothrow_copy</span></a></strong></span></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_nothrow_copy.html" title="has_nothrow_copy"><span class="index-entry-level-1">has_nothrow_copy_constructor</span></a></p></li> +</ul></div> +</li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">has_nothrow_copy_constructor</span></p> +<div class="index"><ul class="index" type="none" compact><li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_nothrow_copy.html" title="has_nothrow_copy"><span class="index-entry-level-1">has_nothrow_copy</span></a></p></li></ul></div> +</li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">has_nothrow_default_constructor</span></p> +<div class="index"><ul class="index" type="none" compact><li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_nothrow_constructor.html" title="has_nothrow_constructor"><span class="index-entry-level-1">has_nothrow_constructor</span></a></p></li></ul></div> +</li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">has_not_equal_to</span></p> +<div class="index"><ul class="index" type="none" compact> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_not_equal_to.html" title="has_not_equal_to"><span class="index-entry-level-1">dont_care</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><span class="bold"><strong><a class="link" href="../boost_typetraits/reference/has_not_equal_to.html" title="has_not_equal_to"><span class="index-entry-level-1">has_not_equal_to</span></a></strong></span></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_not_equal_to.html" title="has_not_equal_to"><span class="index-entry-level-1">trait</span></a></p></li> +</ul></div> +</li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">has_operator</span></p> +<div class="index"><ul class="index" type="none" compact><li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/category/value_traits/operators.html" title="Operator Type Traits"><span class="index-entry-level-1">Operator Type Traits</span></a></p></li></ul></div> +</li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">has_plus</span></p> +<div class="index"><ul class="index" type="none" compact> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_plus.html" title="has_plus"><span class="index-entry-level-1">dont_care</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><span class="bold"><strong><a class="link" href="../boost_typetraits/reference/has_plus.html" title="has_plus"><span class="index-entry-level-1">has_plus</span></a></strong></span></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_plus.html" title="has_plus"><span class="index-entry-level-1">trait</span></a></p></li> +</ul></div> +</li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">has_plus_assign</span></p> +<div class="index"><ul class="index" type="none" compact> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_plus_assign.html" title="has_plus_assign"><span class="index-entry-level-1">dont_care</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><span class="bold"><strong><a class="link" href="../boost_typetraits/reference/has_plus_assign.html" title="has_plus_assign"><span class="index-entry-level-1">has_plus_assign</span></a></strong></span></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_plus_assign.html" title="has_plus_assign"><span class="index-entry-level-1">trait</span></a></p></li> +</ul></div> +</li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">has_post_decrement</span></p> +<div class="index"><ul class="index" type="none" compact> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_post_decrement.html" title="has_post_decrement"><span class="index-entry-level-1">dont_care</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><span class="bold"><strong><a class="link" href="../boost_typetraits/reference/has_post_decrement.html" title="has_post_decrement"><span class="index-entry-level-1">has_post_decrement</span></a></strong></span></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_post_decrement.html" title="has_post_decrement"><span class="index-entry-level-1">trait</span></a></p></li> +</ul></div> +</li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">has_post_increment</span></p> +<div class="index"><ul class="index" type="none" compact> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_post_increment.html" title="has_post_increment"><span class="index-entry-level-1">dont_care</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><span class="bold"><strong><a class="link" href="../boost_typetraits/reference/has_post_increment.html" title="has_post_increment"><span class="index-entry-level-1">has_post_increment</span></a></strong></span></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_post_increment.html" title="has_post_increment"><span class="index-entry-level-1">trait</span></a></p></li> +</ul></div> +</li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">has_pre_decrement</span></p> +<div class="index"><ul class="index" type="none" compact> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_pre_decrement.html" title="has_pre_decrement"><span class="index-entry-level-1">dont_care</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><span class="bold"><strong><a class="link" href="../boost_typetraits/reference/has_pre_decrement.html" title="has_pre_decrement"><span class="index-entry-level-1">has_pre_decrement</span></a></strong></span></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_pre_decrement.html" title="has_pre_decrement"><span class="index-entry-level-1">trait</span></a></p></li> +</ul></div> +</li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">has_pre_increment</span></p> +<div class="index"><ul class="index" type="none" compact> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_pre_increment.html" title="has_pre_increment"><span class="index-entry-level-1">dont_care</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><span class="bold"><strong><a class="link" href="../boost_typetraits/reference/has_pre_increment.html" title="has_pre_increment"><span class="index-entry-level-1">has_pre_increment</span></a></strong></span></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_pre_increment.html" title="has_pre_increment"><span class="index-entry-level-1">trait</span></a></p></li> +</ul></div> +</li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">has_right_shift</span></p> +<div class="index"><ul class="index" type="none" compact> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_right_shift.html" title="has_right_shift"><span class="index-entry-level-1">dont_care</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><span class="bold"><strong><a class="link" href="../boost_typetraits/reference/has_right_shift.html" title="has_right_shift"><span class="index-entry-level-1">has_right_shift</span></a></strong></span></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_right_shift.html" title="has_right_shift"><span class="index-entry-level-1">trait</span></a></p></li> +</ul></div> +</li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">has_right_shift_assign</span></p> +<div class="index"><ul class="index" type="none" compact> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_right_shift_assign.html" title="has_right_shift_assign"><span class="index-entry-level-1">dont_care</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><span class="bold"><strong><a class="link" href="../boost_typetraits/reference/has_right_shift_assign.html" title="has_right_shift_assign"><span class="index-entry-level-1">has_right_shift_assign</span></a></strong></span></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_right_shift_assign.html" title="has_right_shift_assign"><span class="index-entry-level-1">trait</span></a></p></li> +</ul></div> +</li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">has_trivial_assign</span></p> +<div class="index"><ul class="index" type="none" compact> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_trivial_assign.html" title="has_trivial_assign"><span class="index-entry-level-1">BOOST_HAS_TRIVIAL_ASSIGN</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><span class="bold"><strong><a class="link" href="../boost_typetraits/reference/has_trivial_assign.html" title="has_trivial_assign"><span class="index-entry-level-1">has_trivial_assign</span></a></strong></span></p></li> +</ul></div> +</li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">has_trivial_constructor</span></p> +<div class="index"><ul class="index" type="none" compact> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_trivial_constructor.html" title="has_trivial_constructor"><span class="index-entry-level-1">BOOST_HAS_TRIVIAL_CONSTRUCTOR</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><span class="bold"><strong><a class="link" href="../boost_typetraits/reference/has_trivial_constructor.html" title="has_trivial_constructor"><span class="index-entry-level-1">has_trivial_constructor</span></a></strong></span></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_trivial_constructor.html" title="has_trivial_constructor"><span class="index-entry-level-1">has_trivial_default_constructor</span></a></p></li> +</ul></div> +</li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">has_trivial_copy</span></p> +<div class="index"><ul class="index" type="none" compact> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_trivial_copy.html" title="has_trivial_copy"><span class="index-entry-level-1">BOOST_HAS_TRIVIAL_COPY</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><span class="bold"><strong><a class="link" href="../boost_typetraits/reference/has_trivial_copy.html" title="has_trivial_copy"><span class="index-entry-level-1">has_trivial_copy</span></a></strong></span></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_trivial_copy.html" title="has_trivial_copy"><span class="index-entry-level-1">has_trivial_copy_constructor</span></a></p></li> +</ul></div> +</li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">has_trivial_copy_constructor</span></p> +<div class="index"><ul class="index" type="none" compact><li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_trivial_copy.html" title="has_trivial_copy"><span class="index-entry-level-1">has_trivial_copy</span></a></p></li></ul></div> +</li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">has_trivial_default_constructor</span></p> +<div class="index"><ul class="index" type="none" compact><li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_trivial_constructor.html" title="has_trivial_constructor"><span class="index-entry-level-1">has_trivial_constructor</span></a></p></li></ul></div> +</li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">has_trivial_destructor</span></p> +<div class="index"><ul class="index" type="none" compact> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_trivial_destructor.html" title="has_trivial_destructor"><span class="index-entry-level-1">BOOST_HAS_TRIVIAL_DESTRUCTOR</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><span class="bold"><strong><a class="link" href="../boost_typetraits/reference/has_trivial_destructor.html" title="has_trivial_destructor"><span class="index-entry-level-1">has_trivial_destructor</span></a></strong></span></p></li> +</ul></div> +</li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">has_unary_minus</span></p> +<div class="index"><ul class="index" type="none" compact> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_unary_minus.html" title="has_unary_minus"><span class="index-entry-level-1">dont_care</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><span class="bold"><strong><a class="link" href="../boost_typetraits/reference/has_unary_minus.html" title="has_unary_minus"><span class="index-entry-level-1">has_unary_minus</span></a></strong></span></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/category/value_traits/operators.html" title="Operator Type Traits"><span class="index-entry-level-1">Operator Type Traits</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_unary_minus.html" title="has_unary_minus"><span class="index-entry-level-1">trait</span></a></p></li> +</ul></div> +</li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">has_unary_plus</span></p> +<div class="index"><ul class="index" type="none" compact> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_unary_plus.html" title="has_unary_plus"><span class="index-entry-level-1">dont_care</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><span class="bold"><strong><a class="link" href="../boost_typetraits/reference/has_unary_plus.html" title="has_unary_plus"><span class="index-entry-level-1">has_unary_plus</span></a></strong></span></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_unary_plus.html" title="has_unary_plus"><span class="index-entry-level-1">trait</span></a></p></li> +</ul></div> +</li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">has_virtual_destructor</span></p> +<div class="index"><ul class="index" type="none" compact> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_virtual_destructor.html" title="has_virtual_destructor"><span class="index-entry-level-1">BOOST_HAS_VIRTUAL_DESTRUCTOR</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><span class="bold"><strong><a class="link" href="../boost_typetraits/reference/has_virtual_destructor.html" title="has_virtual_destructor"><span class="index-entry-level-1">has_virtual_destructor</span></a></strong></span></p></li> +</ul></div> +</li> +</ul></div></dd> +<dt> +<a name="idx_id_52"></a><span class="term">I</span> +</dt> +<dd><div class="index"><ul class="index" type="none" compact> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">Improving std::min with common_type</span></p> +<div class="index"><ul class="index" type="none" compact><li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/examples/improved_min.html" title="Improving std::min with common_type"><span class="index-entry-level-1">common_type</span></a></p></li></ul></div> +</li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">int</span></p> +<div class="index"><ul class="index" type="none" compact><li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/is_function.html" title="is_function"><span class="index-entry-level-1">is_function</span></a></p></li></ul></div> +</li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">integral_constant</span></p> +<div class="index"><ul class="index" type="none" compact> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/alignment_of.html" title="alignment_of"><span class="index-entry-level-1">alignment_of</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/extent.html" title="extent"><span class="index-entry-level-1">extent</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/integral_constant.html" title="integral_constant"><span class="index-entry-level-1">false_type</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><span class="bold"><strong><a class="link" href="../boost_typetraits/reference/integral_constant.html" title="integral_constant"><span class="index-entry-level-1">integral_constant</span></a></strong></span></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/category/value_traits/operators.html" title="Operator Type Traits"><span class="index-entry-level-1">Operator Type Traits</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/rank.html" title="rank"><span class="index-entry-level-1">rank</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/integral_constant.html" title="integral_constant"><span class="index-entry-level-1">true_type</span></a></p></li> +</ul></div> +</li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/integral_promotion.html" title="integral_promotion"><span class="index-entry-level-0">integral_promotion</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/is_abstract.html" title="is_abstract"><span class="index-entry-level-0">is_abstract</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/is_arithmetic.html" title="is_arithmetic"><span class="index-entry-level-0">is_arithmetic</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/is_array.html" title="is_array"><span class="index-entry-level-0">is_array</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/is_base_of.html" title="is_base_of"><span class="index-entry-level-0">is_base_of</span></a></p></li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">is_class</span></p> +<div class="index"><ul class="index" type="none" compact> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/is_class.html" title="is_class"><span class="index-entry-level-1">BOOST_IS_CLASS</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><span class="bold"><strong><a class="link" href="../boost_typetraits/reference/is_class.html" title="is_class"><span class="index-entry-level-1">is_class</span></a></strong></span></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/user_defined.html" title="User Defined Specializations"><span class="index-entry-level-1">User Defined Specializations</span></a></p></li> +</ul></div> +</li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/is_complex.html" title="is_complex"><span class="index-entry-level-0">is_complex</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/is_compound.html" title="is_compound"><span class="index-entry-level-0">is_compound</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/is_const.html" title="is_const"><span class="index-entry-level-0">is_const</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/is_convertible.html" title="is_convertible"><span class="index-entry-level-0">is_convertible</span></a></p></li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">is_convertible_to_Ret</span></p> +<div class="index"><ul class="index" type="none" compact><li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/category/value_traits/operators.html" title="Operator Type Traits"><span class="index-entry-level-1">Operator Type Traits</span></a></p></li></ul></div> +</li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">is_empty</span></p> +<div class="index"><ul class="index" type="none" compact> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/is_empty.html" title="is_empty"><span class="index-entry-level-1">BOOST_IS_EMPTY</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><span class="bold"><strong><a class="link" href="../boost_typetraits/reference/is_empty.html" title="is_empty"><span class="index-entry-level-1">is_empty</span></a></strong></span></p></li> +</ul></div> +</li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/is_enum.html" title="is_enum"><span class="index-entry-level-0">is_enum</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/is_floating_point.html" title="is_floating_point"><span class="index-entry-level-0">is_floating_point</span></a></p></li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">is_function</span></p> +<div class="index"><ul class="index" type="none" compact> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/is_function.html" title="is_function"><span class="index-entry-level-1">int</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><span class="bold"><strong><a class="link" href="../boost_typetraits/reference/is_function.html" title="is_function"><span class="index-entry-level-1">is_function</span></a></strong></span></p></li> +</ul></div> +</li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/is_fundamental.html" title="is_fundamental"><span class="index-entry-level-0">is_fundamental</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/is_integral.html" title="is_integral"><span class="index-entry-level-0">is_integral</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/is_lvalue_reference.html" title="is_lvalue_reference"><span class="index-entry-level-0">is_lvalue_reference</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/is_member_function_pointer.html" title="is_member_function_pointer"><span class="index-entry-level-0">is_member_function_pointer</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/is_member_object_pointer.html" title="is_member_object_pointer"><span class="index-entry-level-0">is_member_object_pointer</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/is_member_pointer.html" title="is_member_pointer"><span class="index-entry-level-0">is_member_pointer</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/is_object.html" title="is_object"><span class="index-entry-level-0">is_object</span></a></p></li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">is_pod</span></p> +<div class="index"><ul class="index" type="none" compact> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/is_pod.html" title="is_pod"><span class="index-entry-level-1">BOOST_IS_POD</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><span class="bold"><strong><a class="link" href="../boost_typetraits/reference/is_pod.html" title="is_pod"><span class="index-entry-level-1">is_pod</span></a></strong></span></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/user_defined.html" title="User Defined Specializations"><span class="index-entry-level-1">User Defined Specializations</span></a></p></li> +</ul></div> +</li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">is_pointer</span></p> +<div class="index"><ul class="index" type="none" compact> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/background.html" title="Background and Tutorial"><span class="index-entry-level-1">Background and Tutorial</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><span class="bold"><strong><a class="link" href="../boost_typetraits/reference/is_pointer.html" title="is_pointer"><span class="index-entry-level-1">is_pointer</span></a></strong></span></p></li> +</ul></div> +</li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/is_polymorphic.html" title="is_polymorphic"><span class="index-entry-level-0">is_polymorphic</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/is_reference.html" title="is_reference"><span class="index-entry-level-0">is_reference</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/is_rvalue_reference.html" title="is_rvalue_reference"><span class="index-entry-level-0">is_rvalue_reference</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/is_same.html" title="is_same"><span class="index-entry-level-0">is_same</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/is_scalar.html" title="is_scalar"><span class="index-entry-level-0">is_scalar</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/is_signed.html" title="is_signed"><span class="index-entry-level-0">is_signed</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/is_stateless.html" title="is_stateless"><span class="index-entry-level-0">is_stateless</span></a></p></li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">is_union</span></p> +<div class="index"><ul class="index" type="none" compact> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/is_union.html" title="is_union"><span class="index-entry-level-1">BOOST_IS_UNION</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><span class="bold"><strong><a class="link" href="../boost_typetraits/reference/is_union.html" title="is_union"><span class="index-entry-level-1">is_union</span></a></strong></span></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/user_defined.html" title="User Defined Specializations"><span class="index-entry-level-1">User Defined Specializations</span></a></p></li> +</ul></div> +</li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/is_unsigned.html" title="is_unsigned"><span class="index-entry-level-0">is_unsigned</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/is_virtual_base_of.html" title="is_virtual_base_of"><span class="index-entry-level-0">is_virtual_base_of</span></a></p></li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">is_void</span></p> +<div class="index"><ul class="index" type="none" compact> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/background.html" title="Background and Tutorial"><span class="index-entry-level-1">Background and Tutorial</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><span class="bold"><strong><a class="link" href="../boost_typetraits/reference/is_void.html" title="is_void"><span class="index-entry-level-1">is_void</span></a></strong></span></p></li> +</ul></div> +</li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/is_volatile.html" title="is_volatile"><span class="index-entry-level-0">is_volatile</span></a></p></li> +</ul></div></dd> +<dt> +<a name="idx_id_53"></a><span class="term">M</span> +</dt> +<dd><div class="index"><ul class="index" type="none" compact> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">Macros for Compiler Intrinsics</span></p> +<div class="index"><ul class="index" type="none" compact> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/intrinsics.html#boost_typetraits.intrinsics.macros_for_compiler_intrinsics" title="Table 1.9. Macros for Compiler Intrinsics"><span class="index-entry-level-1">BOOST_ALIGNMENT_OF</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/intrinsics.html#boost_typetraits.intrinsics.macros_for_compiler_intrinsics" title="Table 1.9. Macros for Compiler Intrinsics"><span class="index-entry-level-1">BOOST_HAS_NOTHROW_ASSIGN</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/intrinsics.html#boost_typetraits.intrinsics.macros_for_compiler_intrinsics" title="Table 1.9. Macros for Compiler Intrinsics"><span class="index-entry-level-1">BOOST_HAS_NOTHROW_CONSTRUCTOR</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/intrinsics.html#boost_typetraits.intrinsics.macros_for_compiler_intrinsics" title="Table 1.9. Macros for Compiler Intrinsics"><span class="index-entry-level-1">BOOST_HAS_NOTHROW_COPY</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/intrinsics.html#boost_typetraits.intrinsics.macros_for_compiler_intrinsics" title="Table 1.9. Macros for Compiler Intrinsics"><span class="index-entry-level-1">BOOST_HAS_TRIVIAL_ASSIGN</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/intrinsics.html#boost_typetraits.intrinsics.macros_for_compiler_intrinsics" title="Table 1.9. Macros for Compiler Intrinsics"><span class="index-entry-level-1">BOOST_HAS_TRIVIAL_CONSTRUCTOR</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/intrinsics.html#boost_typetraits.intrinsics.macros_for_compiler_intrinsics" title="Table 1.9. Macros for Compiler Intrinsics"><span class="index-entry-level-1">BOOST_HAS_TRIVIAL_COPY</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/intrinsics.html#boost_typetraits.intrinsics.macros_for_compiler_intrinsics" title="Table 1.9. Macros for Compiler Intrinsics"><span class="index-entry-level-1">BOOST_HAS_TRIVIAL_DESTRUCTOR</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/intrinsics.html#boost_typetraits.intrinsics.macros_for_compiler_intrinsics" title="Table 1.9. Macros for Compiler Intrinsics"><span class="index-entry-level-1">BOOST_HAS_VIRTUAL_DESTRUCTOR</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/intrinsics.html#boost_typetraits.intrinsics.macros_for_compiler_intrinsics" title="Table 1.9. Macros for Compiler Intrinsics"><span class="index-entry-level-1">BOOST_IS_ABSTRACT</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/intrinsics.html#boost_typetraits.intrinsics.macros_for_compiler_intrinsics" title="Table 1.9. Macros for Compiler Intrinsics"><span class="index-entry-level-1">BOOST_IS_BASE_OF</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/intrinsics.html#boost_typetraits.intrinsics.macros_for_compiler_intrinsics" title="Table 1.9. Macros for Compiler Intrinsics"><span class="index-entry-level-1">BOOST_IS_CLASS</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/intrinsics.html#boost_typetraits.intrinsics.macros_for_compiler_intrinsics" title="Table 1.9. Macros for Compiler Intrinsics"><span class="index-entry-level-1">BOOST_IS_CONVERTIBLE</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/intrinsics.html#boost_typetraits.intrinsics.macros_for_compiler_intrinsics" title="Table 1.9. Macros for Compiler Intrinsics"><span class="index-entry-level-1">BOOST_IS_EMPTY</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/intrinsics.html#boost_typetraits.intrinsics.macros_for_compiler_intrinsics" title="Table 1.9. Macros for Compiler Intrinsics"><span class="index-entry-level-1">BOOST_IS_ENUM</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/intrinsics.html#boost_typetraits.intrinsics.macros_for_compiler_intrinsics" title="Table 1.9. Macros for Compiler Intrinsics"><span class="index-entry-level-1">BOOST_IS_POD</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/intrinsics.html#boost_typetraits.intrinsics.macros_for_compiler_intrinsics" title="Table 1.9. Macros for Compiler Intrinsics"><span class="index-entry-level-1">BOOST_IS_POLYMORPHIC</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/intrinsics.html#boost_typetraits.intrinsics.macros_for_compiler_intrinsics" title="Table 1.9. Macros for Compiler Intrinsics"><span class="index-entry-level-1">BOOST_IS_UNION</span></a></p></li> +</ul></div> +</li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/make_signed.html" title="make_signed"><span class="index-entry-level-0">make_signed</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/make_unsigned.html" title="make_unsigned"><span class="index-entry-level-0">make_unsigned</span></a></p></li> +</ul></div></dd> +<dt> +<a name="idx_id_54"></a><span class="term">N</span> +</dt> +<dd><div class="index"><ul class="index" type="none" compact><li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">no_operator</span></p> +<div class="index"><ul class="index" type="none" compact><li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/category/value_traits/operators.html" title="Operator Type Traits"><span class="index-entry-level-1">Operator Type Traits</span></a></p></li></ul></div> +</li></ul></div></dd> +<dt> +<a name="idx_id_55"></a><span class="term">O</span> +</dt> +<dd><div class="index"><ul class="index" type="none" compact> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">Operator Type Traits</span></p> +<div class="index"><ul class="index" type="none" compact> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/category/value_traits/operators.html" title="Operator Type Traits"><span class="index-entry-level-1">any</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/category/value_traits/operators.html" title="Operator Type Traits"><span class="index-entry-level-1">check</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/category/value_traits/operators.html" title="Operator Type Traits"><span class="index-entry-level-1">dont_care</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/category/value_traits/operators.html" title="Operator Type Traits"><span class="index-entry-level-1">has_equal_to</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/category/value_traits/operators.html" title="Operator Type Traits"><span class="index-entry-level-1">has_operator</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/category/value_traits/operators.html" title="Operator Type Traits"><span class="index-entry-level-1">has_unary_minus</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/category/value_traits/operators.html" title="Operator Type Traits"><span class="index-entry-level-1">integral_constant</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/category/value_traits/operators.html" title="Operator Type Traits"><span class="index-entry-level-1">is_convertible_to_Ret</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/category/value_traits/operators.html" title="Operator Type Traits"><span class="index-entry-level-1">no_operator</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/category/value_traits/operators.html" title="Operator Type Traits"><span class="index-entry-level-1">operator_exists</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/category/value_traits/operators.html" title="Operator Type Traits"><span class="index-entry-level-1">operator_returns_Ret</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/category/value_traits/operators.html" title="Operator Type Traits"><span class="index-entry-level-1">operator_returns_void</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/category/value_traits/operators.html" title="Operator Type Traits"><span class="index-entry-level-1">returns_void</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/category/value_traits/operators.html" title="Operator Type Traits"><span class="index-entry-level-1">returns_void_t</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/category/value_traits/operators.html" title="Operator Type Traits"><span class="index-entry-level-1">Rhs_nocv</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/category/value_traits/operators.html" title="Operator Type Traits"><span class="index-entry-level-1">Rhs_noptr</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/category/value_traits/operators.html" title="Operator Type Traits"><span class="index-entry-level-1">Rhs_noref</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/category/value_traits/operators.html" title="Operator Type Traits"><span class="index-entry-level-1">trait</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/category/value_traits/operators.html" title="Operator Type Traits"><span class="index-entry-level-1">trait_impl</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/category/value_traits/operators.html" title="Operator Type Traits"><span class="index-entry-level-1">trait_impl1</span></a></p></li> +</ul></div> +</li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">operator_exists</span></p> +<div class="index"><ul class="index" type="none" compact><li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/category/value_traits/operators.html" title="Operator Type Traits"><span class="index-entry-level-1">Operator Type Traits</span></a></p></li></ul></div> +</li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">operator_returns_Ret</span></p> +<div class="index"><ul class="index" type="none" compact><li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/category/value_traits/operators.html" title="Operator Type Traits"><span class="index-entry-level-1">Operator Type Traits</span></a></p></li></ul></div> +</li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">operator_returns_void</span></p> +<div class="index"><ul class="index" type="none" compact><li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/category/value_traits/operators.html" title="Operator Type Traits"><span class="index-entry-level-1">Operator Type Traits</span></a></p></li></ul></div> +</li> +</ul></div></dd> +<dt> +<a name="idx_id_56"></a><span class="term">P</span> +</dt> +<dd><div class="index"><ul class="index" type="none" compact><li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/promote.html" title="promote"><span class="index-entry-level-0">promote</span></a></p></li></ul></div></dd> +<dt> +<a name="idx_id_57"></a><span class="term">R</span> +</dt> +<dd><div class="index"><ul class="index" type="none" compact> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">rank</span></p> +<div class="index"><ul class="index" type="none" compact> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/rank.html" title="rank"><span class="index-entry-level-1">integral_constant</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><span class="bold"><strong><a class="link" href="../boost_typetraits/reference/rank.html" title="rank"><span class="index-entry-level-1">rank</span></a></strong></span></p></li> +</ul></div> +</li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/remove_all_extents.html" title="remove_all_extents"><span class="index-entry-level-0">remove_all_extents</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/remove_const.html" title="remove_const"><span class="index-entry-level-0">remove_const</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/remove_cv.html" title="remove_cv"><span class="index-entry-level-0">remove_cv</span></a></p></li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">remove_extent</span></p> +<div class="index"><ul class="index" type="none" compact> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/background.html" title="Background and Tutorial"><span class="index-entry-level-1">Background and Tutorial</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><span class="bold"><strong><a class="link" href="../boost_typetraits/reference/remove_extent.html" title="remove_extent"><span class="index-entry-level-1">remove_extent</span></a></strong></span></p></li> +</ul></div> +</li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/remove_pointer.html" title="remove_pointer"><span class="index-entry-level-0">remove_pointer</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/remove_reference.html" title="remove_reference"><span class="index-entry-level-0">remove_reference</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/remove_volatile.html" title="remove_volatile"><span class="index-entry-level-0">remove_volatile</span></a></p></li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">result_type</span></p> +<div class="index"><ul class="index" type="none" compact><li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/function_traits.html" title="function_traits"><span class="index-entry-level-1">function_traits</span></a></p></li></ul></div> +</li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">returns_void</span></p> +<div class="index"><ul class="index" type="none" compact><li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/category/value_traits/operators.html" title="Operator Type Traits"><span class="index-entry-level-1">Operator Type Traits</span></a></p></li></ul></div> +</li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">returns_void_t</span></p> +<div class="index"><ul class="index" type="none" compact><li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/category/value_traits/operators.html" title="Operator Type Traits"><span class="index-entry-level-1">Operator Type Traits</span></a></p></li></ul></div> +</li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">Rhs_nocv</span></p> +<div class="index"><ul class="index" type="none" compact><li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/category/value_traits/operators.html" title="Operator Type Traits"><span class="index-entry-level-1">Operator Type Traits</span></a></p></li></ul></div> +</li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">Rhs_noptr</span></p> +<div class="index"><ul class="index" type="none" compact><li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/category/value_traits/operators.html" title="Operator Type Traits"><span class="index-entry-level-1">Operator Type Traits</span></a></p></li></ul></div> +</li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">Rhs_noref</span></p> +<div class="index"><ul class="index" type="none" compact><li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/category/value_traits/operators.html" title="Operator Type Traits"><span class="index-entry-level-1">Operator Type Traits</span></a></p></li></ul></div> +</li> +</ul></div></dd> +<dt> +<a name="idx_id_58"></a><span class="term">T</span> +</dt> +<dd><div class="index"><ul class="index" type="none" compact> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">trait</span></p> +<div class="index"><ul class="index" type="none" compact> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_bit_and.html" title="has_bit_and"><span class="index-entry-level-1">has_bit_and</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_bit_and_assign.html" title="has_bit_and_assign"><span class="index-entry-level-1">has_bit_and_assign</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_bit_or.html" title="has_bit_or"><span class="index-entry-level-1">has_bit_or</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_bit_or_assign.html" title="has_bit_or_assign"><span class="index-entry-level-1">has_bit_or_assign</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_bit_xor.html" title="has_bit_xor"><span class="index-entry-level-1">has_bit_xor</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_bit_xor_assign.html" title="has_bit_xor_assign"><span class="index-entry-level-1">has_bit_xor_assign</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_complement.html" title="has_complement"><span class="index-entry-level-1">has_complement</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_dereference.html" title="has_dereference"><span class="index-entry-level-1">has_dereference</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_divides.html" title="has_divides"><span class="index-entry-level-1">has_divides</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_divides_assign.html" title="has_divides_assign"><span class="index-entry-level-1">has_divides_assign</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_equal_to.html" title="has_equal_to"><span class="index-entry-level-1">has_equal_to</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_greater.html" title="has_greater"><span class="index-entry-level-1">has_greater</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_greater_equal.html" title="has_greater_equal"><span class="index-entry-level-1">has_greater_equal</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_left_shift.html" title="has_left_shift"><span class="index-entry-level-1">has_left_shift</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_left_shift_assign.html" title="has_left_shift_assign"><span class="index-entry-level-1">has_left_shift_assign</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_less.html" title="has_less"><span class="index-entry-level-1">has_less</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_less_equal.html" title="has_less_equal"><span class="index-entry-level-1">has_less_equal</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_logical_and.html" title="has_logical_and"><span class="index-entry-level-1">has_logical_and</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_logical_not.html" title="has_logical_not"><span class="index-entry-level-1">has_logical_not</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_logical_or.html" title="has_logical_or"><span class="index-entry-level-1">has_logical_or</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_minus.html" title="has_minus"><span class="index-entry-level-1">has_minus</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_minus_assign.html" title="has_minus_assign"><span class="index-entry-level-1">has_minus_assign</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_modulus.html" title="has_modulus"><span class="index-entry-level-1">has_modulus</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_modulus_assign.html" title="has_modulus_assign"><span class="index-entry-level-1">has_modulus_assign</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_multiplies.html" title="has_multiplies"><span class="index-entry-level-1">has_multiplies</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_multiplies_assign.html" title="has_multiplies_assign"><span class="index-entry-level-1">has_multiplies_assign</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_negate.html" title="has_negate"><span class="index-entry-level-1">has_negate</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_not_equal_to.html" title="has_not_equal_to"><span class="index-entry-level-1">has_not_equal_to</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_plus.html" title="has_plus"><span class="index-entry-level-1">has_plus</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_plus_assign.html" title="has_plus_assign"><span class="index-entry-level-1">has_plus_assign</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_post_decrement.html" title="has_post_decrement"><span class="index-entry-level-1">has_post_decrement</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_post_increment.html" title="has_post_increment"><span class="index-entry-level-1">has_post_increment</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_pre_decrement.html" title="has_pre_decrement"><span class="index-entry-level-1">has_pre_decrement</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_pre_increment.html" title="has_pre_increment"><span class="index-entry-level-1">has_pre_increment</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_right_shift.html" title="has_right_shift"><span class="index-entry-level-1">has_right_shift</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_right_shift_assign.html" title="has_right_shift_assign"><span class="index-entry-level-1">has_right_shift_assign</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_unary_minus.html" title="has_unary_minus"><span class="index-entry-level-1">has_unary_minus</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_unary_plus.html" title="has_unary_plus"><span class="index-entry-level-1">has_unary_plus</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/category/value_traits/operators.html" title="Operator Type Traits"><span class="index-entry-level-1">Operator Type Traits</span></a></p></li> +</ul></div> +</li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">trait_impl</span></p> +<div class="index"><ul class="index" type="none" compact><li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/category/value_traits/operators.html" title="Operator Type Traits"><span class="index-entry-level-1">Operator Type Traits</span></a></p></li></ul></div> +</li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">trait_impl1</span></p> +<div class="index"><ul class="index" type="none" compact><li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/category/value_traits/operators.html" title="Operator Type Traits"><span class="index-entry-level-1">Operator Type Traits</span></a></p></li></ul></div> +</li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">true_type</span></p> +<div class="index"><ul class="index" type="none" compact><li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/integral_constant.html" title="integral_constant"><span class="index-entry-level-1">integral_constant</span></a></p></li></ul></div> +</li> +<li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">Type Traits that Transform One Type to Another</span></p> +<div class="index"><ul class="index" type="none" compact><li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/category/transform.html" title="Type Traits that Transform One Type to Another"><span class="index-entry-level-1">BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION</span></a></p></li></ul></div> +</li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/type_with_alignment.html" title="type_with_alignment"><span class="index-entry-level-0">type_with_alignment</span></a></p></li> +</ul></div></dd> +<dt> +<a name="idx_id_59"></a><span class="term">U</span> +</dt> +<dd><div class="index"><ul class="index" type="none" compact><li class="listitem" style="list-style-type: none"> +<p><span class="index-entry-level-0">User Defined Specializations</span></p> +<div class="index"><ul class="index" type="none" compact> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/user_defined.html" title="User Defined Specializations"><span class="index-entry-level-1">is_class</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/user_defined.html" title="User Defined Specializations"><span class="index-entry-level-1">is_pod</span></a></p></li> +<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/user_defined.html" title="User Defined Specializations"><span class="index-entry-level-1">is_union</span></a></p></li> +</ul></div> +</li></ul></div></dd> +</dl></div> +</div> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> +<td align="left"></td> +<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams, + Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten + Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven + Watanabe<p> + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) + </p> +</div></td> +</tr></table> +<hr> +<div class="spirit-nav"> +<a accesskey="p" href="s13.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a> +</div> +</body> +</html> diff --git a/libs/type_traits/doc/index.idx b/libs/type_traits/doc/index.idx new file mode 100644 index 0000000000..e050a9e1f7 --- /dev/null +++ b/libs/type_traits/doc/index.idx @@ -0,0 +1,23 @@ + +!define-scanner class_name "BOOST_TT_AUX_TYPE_TRAIT_DEF\d\s*\(\s*(\w+)\s*[,)]" "(?:class|struct)[^;{]+\\<\1\\>[^;{]+\\{" \1 +!define-scanner class_name "BOOST_TT_AUX_BOOL_TRAIT_DEF\d\s*\(\s*(\w+)\s*[,)]" "(?:class|struct)[^;{]+\\<\1\\>[^;{]+\\{" \1 +!define-scanner class_name "BOOST_TT_AUX_SIZE_T_TRAIT_DEF\d\s*\(\s*(\w+)\s*[,)]" "(?:class|struct)[^;{]+\\<\1\\>[^;{]+\\{" \1 +!define-scanner class_name "BOOST_TT_TRAIT_NAME\s*(\w+)" "(?:class|struct)[^;{]+\\<\1\\>[^;{]+\\{" \1 + +!define-scanner class_name "^[[:space:]]*(template[[:space:]]*<[^;:{]+>[[:space:]]*)?(class|struct)[[:space:]]*(\<\w+\>([[:blank:]]*\([^)]*\))?[[:space:]]*)*(\<\w*\>)[[:space:]]*(<[^;:{]+>)?[[:space:]]*(\{|:[^;\{()]*\{)" "(?:class|struct)[^;{]+\\<\5\\>[^;{]+\\{" \5 +!define-scanner typedef_name "typedef[^;{}#]+?(\w+)\s*;" "typedef[^;]+\\<\1\\>\\s*;" "\1" +!define-scanner "macro_name" "^\s*#\s*define\s+(\w+)" "\\<\1\\>" "\1" +!define-scanner "function_name" "\w+\s+(\w+)\s*\([^\)]*\)\s*[;{]" "\\<\\w+\\>\\s+\\<\1\\>\\s*\\([^;{]*\\)\\s*[;{]" "\1" + +!scan-path boost/type_traits .*\.hpp true +!scan boost/aligned_storage.hpp +!scan boost/type_traits.hpp + +!exclude type arg1_type arg2_type arg3_type arg4_type arg5_type B D +!exclude result + +!rewrite-name "(?:A|An|The)\s+(.*)" "\1" + + + + diff --git a/libs/type_traits/doc/integral_constant.qbk b/libs/type_traits/doc/integral_constant.qbk new file mode 100644 index 0000000000..58403cf1fb --- /dev/null +++ b/libs/type_traits/doc/integral_constant.qbk @@ -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] + diff --git a/libs/type_traits/doc/integral_promotion.qbk b/libs/type_traits/doc/integral_promotion.qbk new file mode 100644 index 0000000000..a83d49b39b --- /dev/null +++ b/libs/type_traits/doc/integral_promotion.qbk @@ -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] + diff --git a/libs/type_traits/doc/intrinsics.qbk b/libs/type_traits/doc/intrinsics.qbk new file mode 100644 index 0000000000..2d171f6b05 --- /dev/null +++ b/libs/type_traits/doc/intrinsics.qbk @@ -0,0 +1,72 @@ +[/ + 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 (April 2008) Visual C++ 8 and 9, +GNU GCC 4.3 and MWCW 9 +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]] + + [[BOOST_IS_ABSTRACT(T)][Should evaluate to true if T is an abstract type]] + [[BOOST_IS_BASE_OF(T,U)][Should evaluate to true if T is a base class of U]] + [[BOOST_IS_CLASS(T)][Should evaluate to true if T is a class type]] + [[BOOST_IS_CONVERTIBLE(T,U)][Should evaluate to true if T is convertible to U]] + [[BOOST_IS_ENUM(T)][Should evaluate to true is T is an enum]] + [[BOOST_IS_POLYMORPHIC(T)][Should evaluate to true if T is a polymorphic type]] + [[BOOST_ALIGNMENT_OF(T)][Should evaluate to the alignment requirements of type T.]] + +] + +[endsect] + diff --git a/libs/type_traits/doc/is_abstract.qbk b/libs/type_traits/doc/is_abstract.qbk new file mode 100644 index 0000000000..3f5415d989 --- /dev/null +++ b/libs/type_traits/doc/is_abstract.qbk @@ -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] + diff --git a/libs/type_traits/doc/is_arithmetic.qbk b/libs/type_traits/doc/is_arithmetic.qbk new file mode 100644 index 0000000000..efea08725e --- /dev/null +++ b/libs/type_traits/doc/is_arithmetic.qbk @@ -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] + diff --git a/libs/type_traits/doc/is_array.qbk b/libs/type_traits/doc/is_array.qbk new file mode 100644 index 0000000000..be384f32e5 --- /dev/null +++ b/libs/type_traits/doc/is_array.qbk @@ -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] + diff --git a/libs/type_traits/doc/is_base_of.qbk b/libs/type_traits/doc/is_base_of.qbk new file mode 100644 index 0000000000..6ee3f43950 --- /dev/null +++ b/libs/type_traits/doc/is_base_of.qbk @@ -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: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 +class type 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 inherit from __true_type if X is a class type. +This is a change in behaviour +from Boost-1.39.0 in order to track the emerging C++0x standard. + +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, Base>::value` is an integral constant +expression that evaluates to /true/: a class is regarded as it's own base.] + +[:`is_base_of<T, T>::value_type` is the type `bool`.] + +[endsect] + + diff --git a/libs/type_traits/doc/is_class.qbk b/libs/type_traits/doc/is_class.qbk new file mode 100644 index 0000000000..1e7879e586 --- /dev/null +++ b/libs/type_traits/doc/is_class.qbk @@ -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:is_class is_class] + template <class T> + struct is_class : public __tof {}; + +__inherit If T is a (possibly cv-qualified) class type (and not a union 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 2011) compilers more recent than Visual C++ 8, GCC-4.3, Greenhills 6.0, +Intel-11.0, and Codegear have the necessary compiler __intrinsics to ensure that this +trait "just works". You may also test to see if the necessary __intrinsics are available +by checking to see if the macro `BOOST_IS_CLASS` is defined. + +__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] + diff --git a/libs/type_traits/doc/is_complex.qbk b/libs/type_traits/doc/is_complex.qbk new file mode 100644 index 0000000000..0c4f9818da --- /dev/null +++ b/libs/type_traits/doc/is_complex.qbk @@ -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] + diff --git a/libs/type_traits/doc/is_compound.qbk b/libs/type_traits/doc/is_compound.qbk new file mode 100644 index 0000000000..392efd5b35 --- /dev/null +++ b/libs/type_traits/doc/is_compound.qbk @@ -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] + diff --git a/libs/type_traits/doc/is_const.qbk b/libs/type_traits/doc/is_const.qbk new file mode 100644 index 0000000000..ed3acaa7d6 --- /dev/null +++ b/libs/type_traits/doc/is_const.qbk @@ -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] + diff --git a/libs/type_traits/doc/is_convertible.qbk b/libs/type_traits/doc/is_convertible.qbk new file mode 100644 index 0000000000..cbaf2fb62b --- /dev/null +++ b/libs/type_traits/doc/is_convertible.qbk @@ -0,0 +1,67 @@ +[/ + 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 rvalue 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, int>::value` is an integral constant +expression that evaluates to /true/.] + +[:`is_convertible<T, T>::value_type` is the type `bool`.] + +[endsect] + + diff --git a/libs/type_traits/doc/is_empty.qbk b/libs/type_traits/doc/is_empty.qbk new file mode 100644 index 0000000000..e89e9a414c --- /dev/null +++ b/libs/type_traits/doc/is_empty.qbk @@ -0,0 +1,46 @@ +[/ + 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 (and not a union 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 - this latter case can be tested for +by checking to see if the macro BOOST_IS_EMPTY is defined. + +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] + diff --git a/libs/type_traits/doc/is_enum.qbk b/libs/type_traits/doc/is_enum.qbk new file mode 100644 index 0000000000..d937fa6ff8 --- /dev/null +++ b/libs/type_traits/doc/is_enum.qbk @@ -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] + diff --git a/libs/type_traits/doc/is_floating_point.qbk b/libs/type_traits/doc/is_floating_point.qbk new file mode 100644 index 0000000000..43f043b326 --- /dev/null +++ b/libs/type_traits/doc/is_floating_point.qbk @@ -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] + diff --git a/libs/type_traits/doc/is_function.qbk b/libs/type_traits/doc/is_function.qbk new file mode 100644 index 0000000000..06f7ed8af3 --- /dev/null +++ b/libs/type_traits/doc/is_function.qbk @@ -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] + diff --git a/libs/type_traits/doc/is_fundamental.qbk b/libs/type_traits/doc/is_fundamental.qbk new file mode 100644 index 0000000000..8e4b4b078a --- /dev/null +++ b/libs/type_traits/doc/is_fundamental.qbk @@ -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] + diff --git a/libs/type_traits/doc/is_integral.qbk b/libs/type_traits/doc/is_integral.qbk new file mode 100644 index 0000000000..5d4add22eb --- /dev/null +++ b/libs/type_traits/doc/is_integral.qbk @@ -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] + diff --git a/libs/type_traits/doc/is_lvalue_reference.qbk b/libs/type_traits/doc/is_lvalue_reference.qbk new file mode 100644 index 0000000000..bd5349c040 --- /dev/null +++ b/libs/type_traits/doc/is_lvalue_reference.qbk @@ -0,0 +1,40 @@ +[/ + Copyright 2010 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_lvalue_reference is_lvalue_reference] + template <class T> + struct is_lvalue_reference : public __tof {}; + +__inherit If T is an lvalue reference 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_lvalue_reference.hpp>` or ` #include <boost/type_traits.hpp>` + +__examples + +[:`is_lvalue_reference<int&>` inherits from `__true_type`.] + +[:`is_lvalue_reference<int const&>::type` is the type `__true_type`.] + +[:`is_lvalue_reference<int const&&>::type` is the type `__false_type`.] + +[:`is_lvalue_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_lvalue_reference<T>::value_type` is the type `bool`.] + +[endsect] + diff --git a/libs/type_traits/doc/is_member_function_pointer.qbk b/libs/type_traits/doc/is_member_function_pointer.qbk new file mode 100644 index 0000000000..673b306808 --- /dev/null +++ b/libs/type_traits/doc/is_member_function_pointer.qbk @@ -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] + diff --git a/libs/type_traits/doc/is_member_object_pointer.qbk b/libs/type_traits/doc/is_member_object_pointer.qbk new file mode 100644 index 0000000000..87510a9304 --- /dev/null +++ b/libs/type_traits/doc/is_member_object_pointer.qbk @@ -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] + diff --git a/libs/type_traits/doc/is_member_pointer.qbk b/libs/type_traits/doc/is_member_pointer.qbk new file mode 100644 index 0000000000..f45372f4b9 --- /dev/null +++ b/libs/type_traits/doc/is_member_pointer.qbk @@ -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] + diff --git a/libs/type_traits/doc/is_object.qbk b/libs/type_traits/doc/is_object.qbk new file mode 100644 index 0000000000..4f14c4497e --- /dev/null +++ b/libs/type_traits/doc/is_object.qbk @@ -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] + diff --git a/libs/type_traits/doc/is_pod.qbk b/libs/type_traits/doc/is_pod.qbk new file mode 100644 index 0000000000..1c36dc7db6 --- /dev/null +++ b/libs/type_traits/doc/is_pod.qbk @@ -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: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 2011) compilers more recent than Visual C++ 8, GCC-4.3, Greenhills 6.0, +Intel-11.0, and Codegear have the necessary compiler __intrinsics to ensure that this +trait "just works". You may also test to see if the necessary __intrinsics are available +by checking to see if the macro `BOOST_IS_POD` is defined. + + +__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] + diff --git a/libs/type_traits/doc/is_pointer.qbk b/libs/type_traits/doc/is_pointer.qbk new file mode 100644 index 0000000000..da57229883 --- /dev/null +++ b/libs/type_traits/doc/is_pointer.qbk @@ -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] + diff --git a/libs/type_traits/doc/is_polymorphic.qbk b/libs/type_traits/doc/is_polymorphic.qbk new file mode 100644 index 0000000000..c4ace0414f --- /dev/null +++ b/libs/type_traits/doc/is_polymorphic.qbk @@ -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] + diff --git a/libs/type_traits/doc/is_reference.qbk b/libs/type_traits/doc/is_reference.qbk new file mode 100644 index 0000000000..baf6bf4a49 --- /dev/null +++ b/libs/type_traits/doc/is_reference.qbk @@ -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_reference is_reference] + template <class T> + struct is_reference : public __tof {}; + +__inherit If T is a reference type (either an lvalue reference or an rvalue reference) +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 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] + diff --git a/libs/type_traits/doc/is_rvalue_reference.qbk b/libs/type_traits/doc/is_rvalue_reference.qbk new file mode 100644 index 0000000000..edf096444d --- /dev/null +++ b/libs/type_traits/doc/is_rvalue_reference.qbk @@ -0,0 +1,40 @@ +[/ + Copyright 2010 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_rvalue_reference is_rvalue_reference] + template <class T> + struct is_rvalue_reference : public __tof {}; + +__inherit If T is an rvalue reference 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_rvalue_reference.hpp>` or ` #include <boost/type_traits.hpp>` + +__examples + +[:`is_rvalue_reference<int&&>` inherits from `__true_type`.] + +[:`is_rvalue_reference<int const&&>::type` is the type `__true_type`.] + +[:`is_rvalue_reference<int const&>::type` is the type `__false_type`.] + +[:`is_rvalue_reference<int (&&)(long)>::value` is an integral constant +expression that evaluates to /true/ (the argument in this case is +an rvalue reference to a function).] + +[:`is_rvalue_reference<T>::value_type` is the type `bool`.] + +[endsect] + diff --git a/libs/type_traits/doc/is_same.qbk b/libs/type_traits/doc/is_same.qbk new file mode 100644 index 0000000000..d054988a3e --- /dev/null +++ b/libs/type_traits/doc/is_same.qbk @@ -0,0 +1,39 @@ +[/ + 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, T>::value_type` is the type `bool`.] + +[endsect] + + diff --git a/libs/type_traits/doc/is_scalar.qbk b/libs/type_traits/doc/is_scalar.qbk new file mode 100644 index 0000000000..4ec966c25a --- /dev/null +++ b/libs/type_traits/doc/is_scalar.qbk @@ -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] + diff --git a/libs/type_traits/doc/is_signed.qbk b/libs/type_traits/doc/is_signed.qbk new file mode 100644 index 0000000000..8d43c91e8c --- /dev/null +++ b/libs/type_traits/doc/is_signed.qbk @@ -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] + diff --git a/libs/type_traits/doc/is_stateless.qbk b/libs/type_traits/doc/is_stateless.qbk new file mode 100644 index 0000000000..d2de82f4a1 --- /dev/null +++ b/libs/type_traits/doc/is_stateless.qbk @@ -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_stateless is_stateless] + template <class T> + struct is_stateless : public __tof {}; + +__inherit If 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 2011) compilers more recent than Visual C++ 8, GCC-4.3, Greenhills 6.0, +Intel-11.0, and Codegear have the necessary compiler __intrinsics to ensure that this +trait "just works". + +[endsect] + diff --git a/libs/type_traits/doc/is_union.qbk b/libs/type_traits/doc/is_union.qbk new file mode 100644 index 0000000000..e8203b733d --- /dev/null +++ b/libs/type_traits/doc/is_union.qbk @@ -0,0 +1,48 @@ +[/ + 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 2011) compilers more recent than Visual C++ 8, GCC-4.3, Greenhills 6.0, +Intel-11.0, and Codegear have the necessary compiler __intrinsics to ensure that this +trait "just works". You may also test to see if the necessary __intrinsics are available +by checking to see if the macro `BOOST_IS_UNION` is defined. + + +__header ` #include <boost/type_traits/is_union.hpp>` or ` #include <boost/type_traits.hpp>` + +__examples + +Given `union my_union {};` then: + +[:`is_union<my_union>` inherits from `__true_type`.] + +[:`is_union<const my_union>::type` is the type `__true_type`.] + +[:`is_union<my_union>::value` is an integral constant +expression that evaluates to /true/.] + +[:`is_union<my_union*>::value` is an integral constant +expression that evaluates to /false/.] + +[:`is_union<T>::value_type` is the type `bool`.] + +[endsect] + diff --git a/libs/type_traits/doc/is_unsigned.qbk b/libs/type_traits/doc/is_unsigned.qbk new file mode 100644 index 0000000000..adf1926857 --- /dev/null +++ b/libs/type_traits/doc/is_unsigned.qbk @@ -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] + diff --git a/libs/type_traits/doc/is_virtual_base_of.qbk b/libs/type_traits/doc/is_virtual_base_of.qbk new file mode 100644 index 0000000000..e229bc5be7 --- /dev/null +++ b/libs/type_traits/doc/is_virtual_base_of.qbk @@ -0,0 +1,50 @@ +[/ + Copyright 2009 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_virtual_base_of is_virtual_base_of] + template <class Base, class Derived> + struct is_virtual_base_of : public __tof {}; + +__inherit If Base is a virtual base class of type Derived then inherits from __true_type, +otherwise inherits from __false_type. + +Types `Base` and `Derived` must not be incomplete types. + +__std_ref 10. + +__header ` #include <boost/type_traits/is_virtual_base_of.hpp>` or ` #include <boost/type_traits.hpp>` + +__compat this trait also requires a working __is_base_of trait. + +[note +There are a small number of cases where it's simply not possible for this trait to work, and +where attempting to instantiate the trait will cause compiler errors (see bug report +[@https://svn.boost.org/trac/boost/ticket/3730 #3730]). Further more the issues may well +be compiler specific. In this situation the user should supply a full specialization of +the trait to work around the problem.] + +__examples + +[:Given: ` class Base{}; class Derived : public virtual Base{};` ] + +[:`is_virtual_base_of<Base, Derived>` inherits from `__true_type`.] + +[:`is_virtual_base_of<Base, Derived>::type` is the type `__true_type`.] + +[:`is_virtual_base_of<Base, Derived>::value` is an integral constant +expression that evaluates to /true/.] + +[:`is_virtual_base_of<SomeClassType, SomeClassType>::value` is an integral constant +expression that evaluates to /true/.] + +[:`is_virtual_base_of<NotAClassType, NotAClassType>::value` is an integral constant +expression that evaluates to /false/.] + +[:`is_virtual_base_of<T, U>::value_type` is the type `bool`.] + +[endsect] + diff --git a/libs/type_traits/doc/is_void.qbk b/libs/type_traits/doc/is_void.qbk new file mode 100644 index 0000000000..b99e586369 --- /dev/null +++ b/libs/type_traits/doc/is_void.qbk @@ -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] + diff --git a/libs/type_traits/doc/is_volatile.qbk b/libs/type_traits/doc/is_volatile.qbk new file mode 100644 index 0000000000..4ce311ac42 --- /dev/null +++ b/libs/type_traits/doc/is_volatile.qbk @@ -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] + diff --git a/libs/type_traits/doc/make_signed.qbk b/libs/type_traits/doc/make_signed.qbk new file mode 100644 index 0000000000..87fa3acb82 --- /dev/null +++ b/libs/type_traits/doc/make_signed.qbk @@ -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] + diff --git a/libs/type_traits/doc/make_unsigned.qbk b/libs/type_traits/doc/make_unsigned.qbk new file mode 100644 index 0000000000..cd9bd768b4 --- /dev/null +++ b/libs/type_traits/doc/make_unsigned.qbk @@ -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_unsigned<int>::type`][`unsigned int`]] + +[[`make_unsigned<unsigned int const>::type`] [`unsigned int const`]] + +[[`make_unsigned<const unsigned long long>::type`] [`const unsigned long long`]] + +[[`make_unsigned<my_enum>::type`] [An unsigned integer type with the same width as the enum.]] +[[`make_unsigned<wchar_t>::type`] [An unsigned integer type with the same width as wchar_t.]] + +] + +[endsect] + diff --git a/libs/type_traits/doc/mpl.qbk b/libs/type_traits/doc/mpl.qbk new file mode 100644 index 0000000000..cc023d61a3 --- /dev/null +++ b/libs/type_traits/doc/mpl.qbk @@ -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] + diff --git a/libs/type_traits/doc/operators.qbk b/libs/type_traits/doc/operators.qbk new file mode 100644 index 0000000000..6adcf67ce6 --- /dev/null +++ b/libs/type_traits/doc/operators.qbk @@ -0,0 +1,501 @@ +[/ + (C) Copyright 2011 Frederic Bron. + 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). +] +[c++] +[def __binary_temp `< class Lhs, class Rhs=Lhs, class Ret=dont_care >`] +[def __prefix_temp `< class Rhs, class Ret=dont_care >`] +[def __postfix_temp `< class Lhs, class Ret=dont_care >`] + +[section:operators Operator Type Traits] + +[heading Introduction] + +These traits are all /value traits/ inheriting from __integral_constant +and providing a simple `true` or `false` boolean `value` which reflects the fact +that given types can or cannot be used with given operators. + +For example, `has_plus<int, double>::value` is a `bool` +which value is `true` because it is possible to add a `double` to an `int` like +in the following code: +`` +int i; +double d; +i+d; +`` +It is also possible to know if the result of the operator can be used as function argument +of a given type. +For example, `has_plus<int, double, float>::value` is `true` +because it is possible to add a `double` to an `int` and +the result (`double`) can be converted to a `float` argument like in the following code: +`` +void f(float) { }; +int i; +double d; +f(i+d); +`` + +[heading Example of application] + +These traits can be useful to optimize the code for types supporting given operations. +For example a function `std::advance` that increases an iterator of a given number of steps +could be implemented as follows: + +`` +#include <boost/type_traits/has_plus_assign.hpp> + +namespace detail { +template < class Iterator, class Distance, bool has_plus_assign > +struct advance_impl; + +// this is used if += exists (efficient) +template < class Iterator, class Distance > +struct advance_impl<Iterator, Distance, true> { + void operator()(Iterator &i, Distance n) { + i+=n; + } +}; + +// this is use if += does not exists (less efficient but cannot do better) +template < class Iterator, class Distance > +struct advance_impl<Iterator, Distance, false> { + void operator()(Iterator &i, Distance n) { + if (n>0) { + while (n--) ++i; + } else { + while (n++) --i; + } + } +}; +} // namespace detail + +template < class Iterator, class Distance > +inline void advance(Iterator &i, Distance n) { + detail::advance_impl< Iterator, Distance, ::boost::has_plus_assign<Iterator>::value >()(i, n); +} +`` + +Then the compiler chooses the most efficient implementation according to the type's ability to perform `+=` operation: + +`` +#include <iostream> + +class with { + int m_i; + public: + with(int i=0) : m_i(i) { } + with &operator+=(int rhs) { m_i+=rhs; return *this; } + operator int const () { return m_i; } +}; + +class without { + int m_i; + public: + without(int i=0) : m_i(i) { } + without &operator++() { ++m_i; return *this; } + without &operator--() { --m_i; return *this; } + operator int const () { return m_i; } +}; + +int main() { + with i=0; + advance(i, 10); // uses += + std::cout<<"with: "<<i<<'\n'; + without j=0; + advance(j, 10); // uses ++ + std::cout<<"without: "<<j<<'\n'; + return 0; +} +`` + +[heading Description] +The syntax is the following: +`` +template __prefix_temp has_op; // prefix operator +template __postfix_temp has_op; // postfix operator +template __binary_temp has_op; // binary operator +`` +where: + +* op represents the operator name +* `Lhs` is the type used at the left hand side of `operator op`, +* `Rhs` is the type used at the right hand side of `operator op`, +* `Ret` is the type for which we want to know if the result of `operator op` can + be converted to. + +The default behaviour (`Ret=dont_care`) is to not check for the return value of the +operator. +If `Ret` is different from the default `dont_care`, the return value is checked to be +convertible to `Ret`. Convertible to `Ret` means that the return value can be +used as argument to a function expecting `Ret`: +`` +void f(Ret); +Lhs lhs; +Rhs rhs; +f(lhs+rhs); // is valid if has_plus<Lhs, Rhs, Ret>::value==true +`` +If `Ret=void`, the return type is checked to be exactly `void`. + +The following tables give the list of supported binary, prefix and postfix +operators. + +[table Supported prefix operators + [[prefix operator] [trait name]] + [[`!`] [[link boost_typetraits.reference.has_logical_not `has_logical_not`] __prefix_temp]] + [[`+`] [[link boost_typetraits.reference.has_unary_plus `has_unary_plus`]]] + [[`-`] [[link boost_typetraits.reference.has_unary_minus `has_unary_minus`] and [link boost_typetraits.reference.has_negate `has_negate`]]] + [[`~`] [[link boost_typetraits.reference.has_complement `has_complement`]]] + [[`*`] [[link boost_typetraits.reference.has_dereference `has_dereference`]]] + [[`++`] [[link boost_typetraits.reference.has_pre_increment `has_pre_increment`]]] + [[`--`] [[link boost_typetraits.reference.has_pre_decrement `has_pre_decrement`]]] +] + +[table Supported postfix operators + [[postfix operator] [trait name]] + [[`++`] [[link boost_typetraits.reference.has_post_increment `has_post_increment`] __postfix_temp]] + [[`--`] [[link boost_typetraits.reference.has_post_decrement `has_post_decrement`]]] +] + +[table Supported binary operators + [[binary operator] [trait name]] + [[`+`] [[link boost_typetraits.reference.has_plus `has_plus`] __binary_temp]] + [[`-`] [[link boost_typetraits.reference.has_minus `has_minus`]]] + [[`*`] [[link boost_typetraits.reference.has_multiplies `has_multiplies`]]] + [[`/`] [[link boost_typetraits.reference.has_divides `has_divides`]]] + [[`%`] [[link boost_typetraits.reference.has_modulus `has_modulus`]]] + [[`+=`] [[link boost_typetraits.reference.has_plus_assign `has_plus_assign`]]] + [[`-=`] [[link boost_typetraits.reference.has_minus_assign `has_minus_assign`]]] + [[`*=`] [[link boost_typetraits.reference.has_multiplies_assign `has_multiplies_assign`]]] + [[`/=`] [[link boost_typetraits.reference.has_divides_assign `has_divides_assign`]]] + [[`%=`] [[link boost_typetraits.reference.has_modulus_assign `has_modulus_assign`]]] + [[`&`] [[link boost_typetraits.reference.has_bit_and `has_bit_and`]]] + [[`|`] [[link boost_typetraits.reference.has_bit_or `has_bit_or`]]] + [[`^`] [[link boost_typetraits.reference.has_bit_xor `has_bit_xor`]]] + [[`&=`] [[link boost_typetraits.reference.has_bit_and_assign `has_bit_and_assign`]]] + [[`|=`] [[link boost_typetraits.reference.has_bit_or_assign `has_bit_or_assign`]]] + [[`^=`] [[link boost_typetraits.reference.has_bit_xor_assign `has_bit_xor_assign`]]] + [[`<<`] [[link boost_typetraits.reference.has_left_shift `has_left_shift`]]] + [[`>>`] [[link boost_typetraits.reference.has_right_shift `has_right_shift`]]] + [[`<<=`] [[link boost_typetraits.reference.has_left_shift_assign `has_left_shift_assign`]]] + [[`>>=`] [[link boost_typetraits.reference.has_right_shift_assign `has_right_shift_assign`]]] + [[`==`] [[link boost_typetraits.reference.has_equal_to `has_equal_to`]]] + [[`!=`] [[link boost_typetraits.reference.has_not_equal_to `has_not_equal_to`]]] + [[`<`] [[link boost_typetraits.reference.has_less `has_less`]]] + [[`<=`] [[link boost_typetraits.reference.has_less_equal `has_less_equal`]]] + [[`>`] [[link boost_typetraits.reference.has_greater `has_greater`]]] + [[`>=`] [[link boost_typetraits.reference.has_greater_equal `has_greater_equal`]]] + [[`&&`] [[link boost_typetraits.reference.has_logical_and `has_logical_and`]]] + [[`||`] [[link boost_typetraits.reference.has_logical_or `has_logical_or`]]] +] + +The following operators are not supported because they could not be implemented using the same technique: +`operator=`, `operator->`, `operator&`, `operator[]`, `operator,`, `operator()`, `operator new`. + + +[heading cv qualifiers and references] + +A reference sign `&` in the operator argument is ignored so that `has_plus< int&, double& >::value==has_plus< int, double >::value`. +This has been chosen because if the following code works (does not work): +`` +int i; +double d; +i+d; +`` +the following code also works (does not work): +`` +int &ir=i; +double &dr=d; +ir+dr; +`` + +It was not possible to handle properly the `volatile` qualifier so that any construct using this qualifier has undefined behavior. + +As a help, the following tables give the necessary conditions over each trait template argument for the trait `value` to be `true`. +They are non sufficient conditions because the conditions must be `true` for all arguments and return type for `value` to be `true`. + +[table necessary and non sufficient condition on operator argument for value to be true + [[operator declaration] [`has_op< void >`] [`has_op< Arg >` and `has_op< Arg& >`] [`has_op< Arg const >` and `has_op< Arg const& >`]] + [[`operator`@`(Arg)`] [false] [true] [true]] + [[`operator`@`(Arg const)`] [false] [true] [true]] + [[`operator`@`(Arg &)`] [false] [true] [false]] + [[`operator`@`(Arg const &)`] [false] [true] [true]] +] + +[table necessary and non sufficient condition on operator return type for value to be true + [[operator declaration] [`has_op< ..., void >`] [`has_op< ..., Ret >`] [`has_op< ..., Ret const >`] [`has_op< ..., Ret & >`] [`has_op< ..., Ret const & >`]] + [[`void operator`@`(...)`] [true] [false] [false] [false] [false]] + [[`Ret operator`@`(...)`] [false] [true] [true] [false] [true]] + [[`Ret const operator`@`(...)`] [false] [true] [true] [false] [true]] + [[`Ret & operator`@`(...)`] [false] [true] [true] [true] [true]] + [[`Ret const & operator`@`(...)`] [false] [true] [true] [false] [true]] +] + + +[heading Implementation] + +The implementation consists in only header files. +The following headers should included first: +``#include <boost/type_traits/has_operator.hpp>`` +or +``#include <boost/type_traits/has_op.hpp>`` +where [^op] is the textual name chosen for the wanted operator. +The first method includes all operator traits. + +All traits are implemented the same way using preprocessor macros to avoid code +duplication. +The main files are in [^boost/type_traits/detail]: [^has_binary_operator.hpp], +[^has_prefix_operator.hpp] and [^has_postfix_operator.hpp]. +The example of prefix `operator-` is presented below: + +`` +namespace boost { +namespace detail { + +// This namespace ensures that argument-dependent name lookup does not mess things up. +namespace has_unary_minus_impl { + +// 1. a function to have an instance of type T without requiring T to be default +// constructible +template <typename T> T &make(); + + +// 2. we provide our operator definition for types that do not have one already + +// a type returned from operator- when no such operator is +// found in the type's own namespace (our own operator is used) so that we have +// a means to know that our operator was used +struct no_operator { }; + +// this class allows implicit conversions and makes the following operator +// definition less-preferred than any other such operators that might be found +// via argument-dependent name lookup +struct any { template <class T> any(T const&); }; + +// when operator- is not available, this one is used +no_operator operator-(const any&); + + +// 3. checks if the operator returns void or not +// conditions: Rhs!=void + +// we first redefine "operator," so that we have no compilation error if +// operator- returns void and we can use the return type of +// (-rhs, returns_void_t()) to deduce if operator- returns void or not: +// - operator- returns void -> (-rhs, returns_void_t()) returns returns_void_t +// - operator- returns !=void -> (-rhs, returns_void_t()) returns int +struct returns_void_t { }; +template <typename T> int operator,(const T&, returns_void_t); +template <typename T> int operator,(const volatile T&, returns_void_t); + +// this intermediate trait has member value of type bool: +// - value==true -> operator- returns void +// - value==false -> operator- does not return void +template < typename Rhs > +struct operator_returns_void { + // overloads of function returns_void make the difference + // yes_type and no_type have different size by construction + static ::boost::type_traits::yes_type returns_void(returns_void_t); + static ::boost::type_traits::no_type returns_void(int); + static const bool value = sizeof(::boost::type_traits::yes_type)==sizeof(returns_void((-make<Rhs>(),returns_void_t()))); +}; + + +// 4. checks if the return type is Ret or Ret==dont_care +// conditions: Rhs!=void + +struct dont_care { }; + +template < typename Rhs, typename Ret, bool Returns_void > +struct operator_returns_Ret; + +template < typename Rhs > +struct operator_returns_Ret < Rhs, dont_care, true > { + static const bool value = true; +}; + +template < typename Rhs > +struct operator_returns_Ret < Rhs, dont_care, false > { + static const bool value = true; +}; + +template < typename Rhs > +struct operator_returns_Ret < Rhs, void, true > { + static const bool bool value = true; +}; + +template < typename Rhs > +struct operator_returns_Ret < Rhs, void, false > { + static const bool value = false; +}; + +template < typename Rhs, typename Ret > +struct operator_returns_Ret < Rhs, Ret, true > { + static const bool value = false; +}; + +// otherwise checks if it is convertible to Ret using the sizeof trick +// based on overload resolution +// condition: Ret!=void and Ret!=dont_care and the operator does not return void +template < typename Rhs, typename Ret > +struct operator_returns_Ret < Rhs, Ret, false > { + static ::boost::type_traits::yes_type is_convertible_to_Ret(Ret); // this version is preferred for types convertible to Ret + static ::boost::type_traits::no_type is_convertible_to_Ret(...); // this version is used otherwise + + static const bool value = sizeof(is_convertible_to_Ret(-make<Rhs>()))==sizeof(::boost::type_traits::yes_type); +}; + + +// 5. checks for operator existence +// condition: Rhs!=void + +// checks if our definition of operator- is used or an other +// existing one; +// this is done with redefinition of "operator," that returns no_operator or has_operator +struct has_operator { }; +no_operator operator,(no_operator, has_operator); + +template < typename Rhs > +struct operator_exists { + static ::boost::type_traits::yes_type check(has_operator); // this version is preferred when operator exists + static ::boost::type_traits::no_type check(no_operator); // this version is used otherwise + + static const bool value = sizeof(check(((-make<Rhs>()),make<has_operator>())))==sizeof(::boost::type_traits::yes_type); +}; + + +// 6. main trait: to avoid any compilation error, this class behaves +// differently when operator-(Rhs) is forbidden by the standard. +// Forbidden_if is a bool that is: +// - true when the operator-(Rhs) is forbidden by the standard +// (would yield compilation error if used) +// - false otherwise +template < typename Rhs, typename Ret, bool Forbidden_if > +struct trait_impl1; + +template < typename Rhs, typename Ret > +struct trait_impl1 < Rhs, Ret, true > { + static const bool value = false; +}; + +template < typename Rhs, typename Ret > +struct trait_impl1 < Rhs, Ret, false > { + static const bool value = + ::boost::type_traits::ice_and< + operator_exists < Rhs >::value, + operator_returns_Ret < Rhs, Ret, operator_returns_void < Rhs >::value >::value + >::value + ; +}; + +// specialization needs to be declared for the special void case +template < typename Ret > +struct trait_impl1 < void, Ret, false > { + static const bool value = false; +}; + +// defines some typedef for convenience +template < typename Rhs, typename Ret > +struct trait_impl { + typedef typename ::boost::remove_reference<Rhs>::type Rhs_noref; + typedef typename ::boost::remove_cv<Rhs_noref>::type Rhs_nocv; + typedef typename ::boost::remove_cv< typename ::boost::remove_reference< typename ::boost::remove_pointer<Rhs_noref>::type >::type >::type Rhs_noptr; + static const bool value = trait_impl1 < Rhs_noref, Ret, ::boost::is_pointer< Rhs_noref >::value >::value; +}; + +} // namespace impl +} // namespace detail + +// this is the accessible definition of the trait to end user +template < typename Rhs, typename Ret=::boost::detail::has_unary_minus_impl::dont_care > +struct has_unary_minus : ::boost::integral_constant<bool,(::boost::detail::has_unary_minus_impl::trait_impl < Rhs, Ret >::value)> { }; + +} // namespace boost +`` + +[heading Limitation] + +* Requires a compiler with working SFINAE. + +[heading Known issues] + +* These traits cannot detect whether the operators are public or not: +if an operator is defined as a private member of type `T` then +the instantiation of the corresponding trait will produce a compiler error. +For this reason these traits cannot be used to determine whether a type has a +public operator or not. +`` +struct A { private: A operator-(); }; +boost::has_unary_minus<A>::value; // error: A::operator-() is private +`` + +* There is an issue if the operator exists only for type `A` and `B` is +convertible to `A`. In this case, the compiler will report an ambiguous overload +because both the existing operator and the one we provide (with argument of type +`any`) need type conversion, so that none is preferred. +`` +struct A { }; +void operator-(const A&); +struct B { operator A(); }; +boost::has_unary_minus<A>::value; // this is fine +boost::has_unary_minus<B>::value; // error: ambiguous overload between + // operator-(const any&) and + // operator-(const A&) + // both need type conversion +`` +`` +struct B { }; +struct A { A(const B&) { } }; +void operator-(const A&); +boost::has_unary_minus<A>::value; // this is fine +boost::has_unary_minus<B>::value; // error: ambiguous overload between + // operator-(const any&) and + // operator-(const A&) + // both need type conversion +`` + +* There is an issue when applying these traits to template classes. +If the operator is defined but does not bind for a given template type, +it is still detected by the trait which returns `true` instead of `false`. +This applies in particular to the containers of the standard library and `operator==`. +Example: +`` +#include <boost/type_traits/has_equal_to.hpp> +#include <iostream> + +template <class T> +struct contains { T data; }; + +template <class T> +bool operator==(const contains<T> &lhs, const contains<T> &rhs) { + return f(lhs.data, rhs.data); +} + +class bad { }; +class good { }; +bool f(const good&, const good&) { } + +int main() { + std::cout<<std::boolalpha; + // works fine for contains<good> + std::cout<<boost::has_equal_to< contains< good > >::value<<'\n'; // true + contains<good> g; + g==g; // ok + // does not work for contains<bad> + std::cout<<boost::has_equal_to< contains< bad > >::value<<'\n'; // true, should be false + contains<bad> b; + b==b; // compile time error + return 0; +} +`` + +* `volatile` qualifier is not properly handled and would lead to undefined behavior + + +[heading Acknowledgments] + +Frederic Bron is very thankful to numerous people from the boost mailing list for their kind help and patience. +In particular, the following persons have been very helpful for the implementation: Edward Diener, Eric Niebler, Jeffrey Lee Hellrung (Jr.), Robert Stewart, Roman Perepelitsa, Steven Watanabe, Vicente Botet. + +[endsect] diff --git a/libs/type_traits/doc/promote.qbk b/libs/type_traits/doc/promote.qbk new file mode 100644 index 0000000000..3ed5c6f4d8 --- /dev/null +++ b/libs/type_traits/doc/promote.qbk @@ -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] + diff --git a/libs/type_traits/doc/rank.qbk b/libs/type_traits/doc/rank.qbk new file mode 100644 index 0000000000..984a604277 --- /dev/null +++ b/libs/type_traits/doc/rank.qbk @@ -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: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 a (built-in) 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<boost::array<int, 3> >::value` is an integral constant +expression that evaluates to /0/: `boost::array` is a class type and [*not an array type]!] + +[:`rank<T>::value_type` is the type `std::size_t`.] + +[endsect] + diff --git a/libs/type_traits/doc/remove_all_extents.qbk b/libs/type_traits/doc/remove_all_extents.qbk new file mode 100644 index 0000000000..3ab9899e62 --- /dev/null +++ b/libs/type_traits/doc/remove_all_extents.qbk @@ -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] + diff --git a/libs/type_traits/doc/remove_const.qbk b/libs/type_traits/doc/remove_const.qbk new file mode 100644 index 0000000000..9e24aa5896 --- /dev/null +++ b/libs/type_traits/doc/remove_const.qbk @@ -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] + diff --git a/libs/type_traits/doc/remove_cv.qbk b/libs/type_traits/doc/remove_cv.qbk new file mode 100644 index 0000000000..23c342cbe5 --- /dev/null +++ b/libs/type_traits/doc/remove_cv.qbk @@ -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] + diff --git a/libs/type_traits/doc/remove_extent.qbk b/libs/type_traits/doc/remove_extent.qbk new file mode 100644 index 0000000000..445af02e6b --- /dev/null +++ b/libs/type_traits/doc/remove_extent.qbk @@ -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] + diff --git a/libs/type_traits/doc/remove_pointer.qbk b/libs/type_traits/doc/remove_pointer.qbk new file mode 100644 index 0000000000..0504252ab4 --- /dev/null +++ b/libs/type_traits/doc/remove_pointer.qbk @@ -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_pointer remove_pointer] + + template <class T> + struct remove_pointer + { + typedef __below type; + }; + +__type The same type as `T`, but with any pointer modifier removed. Note that pointers to members are left unchanged: +removing the pointer decoration would result in an invalid type. + +__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] + diff --git a/libs/type_traits/doc/remove_reference.qbk b/libs/type_traits/doc/remove_reference.qbk new file mode 100644 index 0000000000..1ed0b96616 --- /dev/null +++ b/libs/type_traits/doc/remove_reference.qbk @@ -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_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*`]] + +[[`remove_reference<int*&>::type`] [`int*`]] + +] + +[endsect] + diff --git a/libs/type_traits/doc/remove_volatile.qbk b/libs/type_traits/doc/remove_volatile.qbk new file mode 100644 index 0000000000..e63beb6e93 --- /dev/null +++ b/libs/type_traits/doc/remove_volatile.qbk @@ -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] + diff --git a/libs/type_traits/doc/transform_traits.qbk b/libs/type_traits/doc/transform_traits.qbk new file mode 100644 index 0000000000..980ebe4e9a --- /dev/null +++ b/libs/type_traits/doc/transform_traits.qbk @@ -0,0 +1,130 @@ +[/ + 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_lvalue_reference; + + template <class T> + struct __add_pointer; + + template <class T> + struct __add_reference; + + template <class T> + struct __add_rvalue_reference; + + template <class T> + struct __add_volatile; + + template <bool B, class T, class U> + struct __conditional; + + template <class... T> + struct __common_type; + + 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] + diff --git a/libs/type_traits/doc/type_traits.qbk b/libs/type_traits/doc/type_traits.qbk new file mode 100644 index 0000000000..104d0e4889 --- /dev/null +++ b/libs/type_traits/doc/type_traits.qbk @@ -0,0 +1,308 @@ +[/ + 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). +] + +[library Boost.TypeTraits + [quickbook 1.5] + [copyright 2000 2011 Adobe Systems Inc, David Abrahams, Frederic Bron, + Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, Jesse Jones, + Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten Ottosen, + Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven Watanabe] + [purpose Meta-programming support library] + [license + 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]) + ] + [authors [authors, various]] + [category template] + [category generic] + [last-revision $Date: 2011-10-09 18:28:33 -0400 (Sun, 09 Oct 2011) $] +] + +[include ../../../tools/auto_index/include/auto_index_helpers.qbk] + +[def __boost_root ../../../../] +[def __tof '''<replaceable><link linkend="boost_typetraits.reference.integral_constant">true_type</link>-or-<link linkend="boost_typetraits.reference.integral_constant">false_type</link></replaceable>'''] +[def __below '''<replaceable>see-below</replaceable>'''] +[def __true_type [link boost_typetraits.reference.integral_constant true_type]] +[def __false_type [link boost_typetraits.reference.integral_constant false_type]] +[def __integral_constant [link boost_typetraits.reference.integral_constant integral_constant]] +[def __inherit [*Inherits:]] +[def __std_ref [*C++ Standard Reference:]] +[def __header [*Header:]] +[def __compat [*Compiler Compatibility:]] +[def __examples [*Examples:]] +[def __type [*type:]] +[def __transform_workaround [link boost_typetraits.category.transform.broken_compiler_workarounds_ compiler workarounds]] +[def __intrinsics [link boost_typetraits.intrinsics intrinsics]] + +[def __is_void [link boost_typetraits.reference.is_void is_void]] +[def __is_integral [link boost_typetraits.reference.is_integral is_integral]] +[def __is_floating_point [link boost_typetraits.reference.is_floating_point is_floating_point]] +[def __is_pointer [link boost_typetraits.reference.is_pointer is_pointer]] +[def __is_reference [link boost_typetraits.reference.is_reference is_reference]] +[def __is_lvalue_reference [link boost_typetraits.reference.is_lvalue_reference is_lvalue_reference]] +[def __is_rvalue_reference [link boost_typetraits.reference.is_rvalue_reference is_rvalue_reference]] +[def __is_member_pointer [link boost_typetraits.reference.is_member_pointer is_member_pointer]] +[def __is_array [link boost_typetraits.reference.is_array is_array]] +[def __is_union [link boost_typetraits.reference.is_union is_union]] +[def __is_class [link boost_typetraits.reference.is_class is_class]] +[def __is_enum [link boost_typetraits.reference.is_enum is_enum]] +[def __is_enum [link boost_typetraits.reference.is_enum is_enum]] +[def __is_function [link boost_typetraits.reference.is_function is_function]] + +[def __is_arithmetic [link boost_typetraits.reference.is_arithmetic is_arithmetic]] +[def __is_fundamental [link boost_typetraits.reference.is_fundamental is_fundamental]] +[def __is_object [link boost_typetraits.reference.is_object is_object]] +[def __is_scalar [link boost_typetraits.reference.is_scalar is_scalar]] +[def __is_compound [link boost_typetraits.reference.is_compound is_compound]] +[def __is_member_function_pointer [link boost_typetraits.reference.is_member_function_pointer is_member_function_pointer]] +[def __is_member_object_pointer [link boost_typetraits.reference.is_member_object_pointer is_member_object_pointer]] + +[def __alignment_of [link boost_typetraits.reference.alignment_of alignment_of]] +[def __rank [link boost_typetraits.reference.rank rank]] +[def __extent [link boost_typetraits.reference.extent extent]] +[def __is_empty [link boost_typetraits.reference.is_empty is_empty]] +[def __is_const [link boost_typetraits.reference.is_const is_const]] +[def __is_volatile [link boost_typetraits.reference.is_volatile is_volatile]] +[def __is_abstract [link boost_typetraits.reference.is_abstract is_abstract]] +[def __is_polymorphic [link boost_typetraits.reference.is_polymorphic is_polymorphic]] +[def __is_signed [link boost_typetraits.reference.is_signed is_signed]] +[def __is_unsigned [link boost_typetraits.reference.is_unsigned is_unsigned]] +[def __has_virtual_destructor [link boost_typetraits.reference.has_virtual_destructor has_virtual_destructor]] +[def __is_pod [link boost_typetraits.reference.is_pod is_pod]] +[def __has_trivial_constructor [link boost_typetraits.reference.has_trivial_constructor has_trivial_constructor]] +[def __has_new_operator [link boost_typetraits.reference.has_new_operator has_new_operator]] +[def __has_trivial_copy [link boost_typetraits.reference.has_trivial_copy has_trivial_copy]] +[def __has_trivial_default_constructor [link boost_typetraits.reference.has_trivial_constructor has_trivial_default_constructor]] +[def __has_trivial_copy_constructor [link boost_typetraits.reference.has_trivial_copy has_trivial_copy_constructor]] +[def __has_trivial_assign [link boost_typetraits.reference.has_trivial_assign has_trivial_assign]] +[def __has_trivial_destructor [link boost_typetraits.reference.has_trivial_destructor has_trivial_destructor]] +[def __is_stateless [link boost_typetraits.reference.is_stateless is_stateless]] +[def __has_nothrow_constructor [link boost_typetraits.reference.has_nothrow_constructor has_nothrow_constructor]] +[def __has_nothrow_copy [link boost_typetraits.reference.has_nothrow_copy has_nothrow_copy]] +[def __has_nothrow_default_constructor [link boost_typetraits.reference.has_nothrow_constructor has_nothrow_default_constructor]] +[def __has_nothrow_copy_constructor [link boost_typetraits.reference.has_nothrow_copy has_nothrow_copy_constructor]] +[def __has_nothrow_assign [link boost_typetraits.reference.has_nothrow_assign has_nothrow_assign]] + +[def __is_base_of [link boost_typetraits.reference.is_base_of is_base_of]] +[def __is_virtual_base_of [link boost_typetraits.reference.is_virtual_base_of is_virtual_base_of]] +[def __is_convertible [link boost_typetraits.reference.is_convertible is_convertible]] +[def __is_same [link boost_typetraits.reference.is_same is_same]] + +[def __remove_const [link boost_typetraits.reference.remove_const remove_const]] +[def __remove_volatile [link boost_typetraits.reference.remove_volatile remove_volatile]] +[def __remove_cv [link boost_typetraits.reference.remove_cv remove_cv]] +[def __remove_reference [link boost_typetraits.reference.remove_reference remove_reference]] +[def __remove_extent [link boost_typetraits.reference.remove_extent remove_extent]] +[def __remove_all_extents [link boost_typetraits.reference.remove_all_extents remove_all_extents]] +[def __remove_pointer [link boost_typetraits.reference.remove_pointer remove_pointer]] +[def __add_reference [link boost_typetraits.reference.add_reference add_reference]] +[def __add_lvalue_reference [link boost_typetraits.reference.add_lvalue_reference add_lvalue_reference]] +[def __add_rvalue_reference [link boost_typetraits.reference.add_rvalue_reference add_rvalue_reference]] +[def __add_pointer [link boost_typetraits.reference.add_pointer add_pointer]] +[def __add_const [link boost_typetraits.reference.add_const add_const]] +[def __add_volatile [link boost_typetraits.reference.add_volatile add_volatile]] +[def __add_cv [link boost_typetraits.reference.add_cv add_cv]] +[def __common_type [link boost_typetraits.reference.common_type common_type]] +[def __conditional [link boost_typetraits.reference.conditional conditional]] + +[def __type_with_alignment [link boost_typetraits.reference.type_with_alignment type_with_alignment]] +[def __aligned_storage [link boost_typetraits.reference.aligned_storage aligned_storage]] + +[def __function_traits [link boost_typetraits.reference.function_traits function_traits]] + +[def __promote [link boost_typetraits.reference.promote promote]] +[def __integral_promotion [link boost_typetraits.reference.integral_promotion integral_promotion]] +[def __floating_point_promotion [link boost_typetraits.reference.floating_point_promotion floating_point_promotion]] + +[def __make_signed [link boost_typetraits.reference.make_signed make_signed]] +[def __make_unsigned [link boost_typetraits.reference.make_unsigned make_unsigned]] +[def __decay [link boost_typetraits.reference.decay decay]] +[def __is_complex [link boost_typetraits.reference.is_complex is_complex]] + +A printer-friendly [@http://sourceforge.net/projects/boost/files/boost-docs/ + PDF version of this manual is also available]. + +[section:intro Introduction] + +The Boost type-traits library contains 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 +the type __true_type if the type has the specified property and inherits from +__false_type otherwise. + +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. + +[endsect] + +[include background.qbk] + +[section:category Type Traits by Category] + +[include value_traits.qbk] +[include transform_traits.qbk] +[include alignment_traits.qbk] +[include decomposing_func.qbk] + +[endsect] + +[include user_defined.qbk] +[include intrinsics.qbk] +[include mpl.qbk] +[include examples.qbk] + +[section:reference Alphabetical Reference] + +[include add_const.qbk] +[include add_cv.qbk] +[include add_lvalue_reference.qbk] +[include add_pointer.qbk] +[include add_reference.qbk] +[include add_rvalue_reference.qbk] +[include add_volatile.qbk] +[include aligned_storage.qbk] +[include alignment_of.qbk] +[include conditional.qbk] +[include common_type.qbk] +[include decay.qbk] +[include extent.qbk] +[include floating_point_promotion.qbk] +[include function_traits.qbk] + +[include has_bit_and.qbk] +[include has_bit_and_assign.qbk] +[include has_bit_or.qbk] +[include has_bit_or_assign.qbk] +[include has_bit_xor.qbk] +[include has_bit_xor_assign.qbk] +[include has_complement.qbk] +[include has_dereference.qbk] +[include has_divides.qbk] +[include has_divides_assign.qbk] +[include has_equal_to.qbk] +[include has_greater.qbk] +[include has_greater_equal.qbk] +[include has_left_shift.qbk] +[include has_left_shift_assign.qbk] +[include has_less.qbk] +[include has_less_equal.qbk] +[include has_logical_and.qbk] +[include has_logical_not.qbk] +[include has_logical_or.qbk] +[include has_minus.qbk] +[include has_minus_assign.qbk] +[include has_modulus.qbk] +[include has_modulus_assign.qbk] +[include has_multiplies.qbk] +[include has_multiplies_assign.qbk] +[include has_negate.qbk] +[include has_new_operator.qbk] +[include has_not_equal_to.qbk] +[include has_nothrow_assign.qbk] +[include has_nothrow_constructor.qbk] +[include has_nothrow_copy.qbk] +[section:has_nothrow_cp_cons has_nothrow_copy_constructor] +See __has_nothrow_copy. +[endsect] +[section:has_no_throw_def_cons has_nothrow_default_constructor] +See __has_nothrow_constructor. +[endsect] +[include has_plus.qbk] +[include has_plus_assign.qbk] +[include has_post_decrement.qbk] +[include has_post_increment.qbk] +[include has_pre_decrement.qbk] +[include has_pre_increment.qbk] +[include has_right_shift.qbk] +[include has_right_shift_assign.qbk] +[include has_trivial_assign.qbk] +[include has_trivial_constructor.qbk] +[include has_trivial_copy.qbk] +[section:has_trivial_cp_cons has_trivial_copy_constructor] +See __has_trivial_copy. +[endsect] +[section:has_trivial_def_cons has_trivial_default_constructor] +See __has_trivial_constructor. +[endsect] +[include has_trivial_destructor.qbk] +[include has_unary_minus.qbk] +[include has_unary_plus.qbk] +[include has_virtual_destructor.qbk] + +[include integral_constant.qbk] +[include integral_promotion.qbk] + +[include is_abstract.qbk] +[include is_arithmetic.qbk] +[include is_array.qbk] +[include is_base_of.qbk] +[include is_class.qbk] +[include is_complex.qbk] +[include is_compound.qbk] +[include is_const.qbk] +[include is_convertible.qbk] +[include is_empty.qbk] +[include is_enum.qbk] +[include is_floating_point.qbk] +[include is_function.qbk] +[include is_fundamental.qbk] +[include is_integral.qbk] +[include is_lvalue_reference.qbk] +[include is_member_function_pointer.qbk] +[include is_member_object_pointer.qbk] +[include is_member_pointer.qbk] +[include is_object.qbk] +[include is_pod.qbk] +[include is_pointer.qbk] +[include is_polymorphic.qbk] +[include is_reference.qbk] +[include is_rvalue_reference.qbk] +[include is_same.qbk] +[include is_scalar.qbk] +[include is_signed.qbk] +[include is_stateless.qbk] +[include is_union.qbk] +[include is_unsigned.qbk] +[include is_virtual_base_of.qbk] +[include is_void.qbk] +[include is_volatile.qbk] + +[include make_signed.qbk] +[include make_unsigned.qbk] + +[include promote.qbk] +[include rank.qbk] + +[include remove_all_extents.qbk] +[include remove_const.qbk] +[include remove_cv.qbk] +[include remove_extent.qbk] +[include remove_pointer.qbk] +[include remove_reference.qbk] +[include remove_volatile.qbk] +[include type_with_alignment.qbk] + +[endsect] + +[include history.qbk] +[include credits.qbk] + +[named_index class_name Class Index] +[named_index typedef_name Typedef Index] +[named_index macro_name Macro Index] +[index] + + + diff --git a/libs/type_traits/doc/type_with_alignment.qbk b/libs/type_traits/doc/type_with_alignment.qbk new file mode 100644 index 0000000000..bed8d138f8 --- /dev/null +++ b/libs/type_traits/doc/type_with_alignment.qbk @@ -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] + diff --git a/libs/type_traits/doc/user_defined.qbk b/libs/type_traits/doc/user_defined.qbk new file mode 100644 index 0000000000..cb0636b628 --- /dev/null +++ b/libs/type_traits/doc/user_defined.qbk @@ -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] + diff --git a/libs/type_traits/doc/value_traits.qbk b/libs/type_traits/doc/value_traits.qbk new file mode 100644 index 0000000000..e3b6c8559a --- /dev/null +++ b/libs/type_traits/doc/value_traits.qbk @@ -0,0 +1,208 @@ +[/ + 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; + + template <class T> + struct __is_class; + + template <class T> + struct __is_complex; + + template <class T> + struct __is_enum; + + template <class T> + struct __is_floating_point; + + template <class T> + struct __is_function; + + template <class T> + struct __is_integral; + + template <class T> + struct __is_member_function_pointer; + + template <class T> + struct __is_member_object_pointer; + + template <class T> + struct __is_pointer; + + template <class T> + struct __is_lvalue_reference; + + template <class T> + struct __is_rvalue_reference; + + template <class T> + struct __is_union; + + template <class T> + struct __is_void; + +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_reference; + + 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_new_operator; + + 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 Base, class Derived> + struct __is_virtual_base_of; + + template <class From, class To> + struct __is_convertible; + + template <class T, class U> + struct __is_same; + +[endsect] + +[include operators.qbk] + +[endsect] diff --git a/libs/type_traits/examples/copy_example.cpp b/libs/type_traits/examples/copy_example.cpp new file mode 100644 index 0000000000..b6bba2cd54 --- /dev/null +++ b/libs/type_traits/examples/copy_example.cpp @@ -0,0 +1,197 @@ + +/* + * + * (C) Copyright John Maddock 1999-2005. + * 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) + * + * This file provides some example of type_traits usage - + * by "optimising" various algorithms: + * + * opt::copy - optimised for trivial copy (cf std::copy) + * + */ + +#include <iostream> +#include <typeinfo> +#include <algorithm> +#include <iterator> +#include <memory> + +#include <boost/test/included/prg_exec_monitor.hpp> +#include <boost/timer.hpp> +#include <boost/type_traits.hpp> + +using std::cout; +using std::endl; +using std::cin; + +namespace opt{ + +// +// opt::copy +// same semantics as std::copy +// calls memcpy where appropiate. +// + +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&) +{ + memmove(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>()); +} + +} // namespace opt + +namespace non_opt +{ + +template<typename I1, typename I2> +inline I2 copy(I1 first, I1 last, I2 out) +{ + return opt::detail::copy_imp(first, last, out, boost::false_type()); +} + +} + +// +// define some global data: +// +const int array_size = 1000; +int i_array_[array_size] = {0,}; +const int ci_array_[array_size] = {0,}; +char c_array_[array_size] = {0,}; +const char cc_array_[array_size] = { 0,}; +// +// since arrays aren't iterators we define a set of pointer +// aliases into the arrays (otherwise the compiler is entitled +// to deduce the type passed to the template functions as +// T (&)[N] rather than T*). +int* i_array = i_array_; +const int* ci_array = ci_array_; +char* c_array = c_array_; +const char* cc_array = cc_array_; + +const int iter_count = 1000000; + +int cpp_main(int argc, char* argv[]) +{ + boost::timer t; + double result; + int i; + cout << "Measuring times in micro-seconds per 1000 elements processed" << endl << endl; + cout << "testing copy...\n" + "[Some standard library versions may already perform this optimisation.]" << endl; + + // cache load: + opt::copy(ci_array, ci_array + array_size, i_array); + + // time optimised version: + t.restart(); + for(i = 0; i < iter_count; ++i) + { + opt::copy(ci_array, ci_array + array_size, i_array); + } + result = t.elapsed(); + cout << "opt::copy<const int*, int*>: " << result << endl; + + // cache load: + non_opt::copy(ci_array, ci_array + array_size, i_array); + + // time non-optimised version: + t.restart(); + for(i = 0; i < iter_count; ++i) + { + non_opt::copy(ci_array, ci_array + array_size, i_array); + } + result = t.elapsed(); + cout << "non_opt::copy<const int*, int*>: " << result << endl; + + // cache load: + std::copy(ci_array, ci_array + array_size, i_array); + + // time standard version: + t.restart(); + for(i = 0; i < iter_count; ++i) + { + std::copy(ci_array, ci_array + array_size, i_array); + } + result = t.elapsed(); + cout << "std::copy<const int*, int*>: " << result << endl; + + // cache load: + opt::copy(cc_array, cc_array + array_size, c_array); + + // time optimised version: + t.restart(); + for(i = 0; i < iter_count; ++i) + { + opt::copy(cc_array, cc_array + array_size, c_array); + } + result = t.elapsed(); + cout << "opt::copy<const char*, char*>: " << result << endl; + + // cache load: + non_opt::copy(cc_array, cc_array + array_size, c_array); + + // time optimised version: + t.restart(); + for(i = 0; i < iter_count; ++i) + { + non_opt::copy(cc_array, cc_array + array_size, c_array); + } + result = t.elapsed(); + cout << "non_opt::copy<const char*, char*>: " << result << endl; + + // cache load: + std::copy(cc_array, cc_array + array_size, c_array); + + // time standard version: + t.restart(); + for(i = 0; i < iter_count; ++i) + { + std::copy(cc_array, cc_array + array_size, c_array); + } + result = t.elapsed(); + cout << "std::copy<const char*, char*>: " << result << endl; + + return 0; +} + + + + + + + + diff --git a/libs/type_traits/examples/fill_example.cpp b/libs/type_traits/examples/fill_example.cpp new file mode 100644 index 0000000000..3e3af06159 --- /dev/null +++ b/libs/type_traits/examples/fill_example.cpp @@ -0,0 +1,200 @@ + +/* + * + * (C) Copyright John Maddock 1999-2005. + * 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) + * + * This file provides some example of type_traits usage - + * by "optimising" various algorithms: + * + * opt::fill - optimised for trivial copy/small types (cf std::fill) + * + */ + +#include <iostream> +#include <typeinfo> +#include <algorithm> +#include <iterator> +#include <memory> +#include <cstring> + +#include <boost/test/included/prg_exec_monitor.hpp> +#include <boost/timer.hpp> +#include <boost/type_traits.hpp> + +#if defined(BOOST_NO_STDC_NAMESPACE) || (defined(std) && defined(__SGI_STL_PORT)) +namespace std{ using :: memset; } +#endif + +using std::cout; +using std::endl; +using std::cin; + +namespace opt{ +// +// 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()); +} + +} // namespace opt + +namespace non_opt{ + +template <class I, class T> +inline void fill(I first, I last, const T& val) +{ + opt::detail::do_fill(first, last, val, boost::false_type()); +} + +} + +// +// define some global data: +// +const int array_size = 1000; +int i_array_[array_size] = {0,}; +const int ci_array_[array_size] = {0,}; +char c_array_[array_size] = {0,}; +const char cc_array_[array_size] = { 0,}; +// +// since arrays aren't iterators we define a set of pointer +// aliases into the arrays (otherwise the compiler is entitled +// to deduce the type passed to the template functions as +// T (&)[N] rather than T*). +int* i_array = i_array_; +const int* ci_array = ci_array_; +char* c_array = c_array_; +const char* cc_array = cc_array_; + +const int iter_count = 1000000; + +int cpp_main(int argc, char* argv[]) +{ + boost::timer t; + double result; + int i; + // + // test destroy_array, + // compare destruction time of an array of ints + // with unoptimised form. + // + cout << "Measuring times in micro-seconds per 1000 elements processed" << endl << endl; + + cout << "testing fill(char)...\n" + "[Some standard library versions may already perform this optimisation.]" << endl; + + // cache load: + opt::fill(c_array, c_array + array_size, (char)3); + + // time optimised version: + t.restart(); + for(i = 0; i < iter_count; ++i) + { + opt::fill(c_array, c_array + array_size, (char)3); + } + result = t.elapsed(); + cout << "opt::fill<char*, char>: " << result << endl; + + // cache load: + non_opt::fill(c_array, c_array + array_size, (char)3); + + // time optimised version: + t.restart(); + for(i = 0; i < iter_count; ++i) + { + non_opt::fill(c_array, c_array + array_size, (char)3); + } + result = t.elapsed(); + cout << "non_opt::fill<char*, char>: " << result << endl; + + // cache load: + std::fill(c_array, c_array + array_size, (char)3); + + // time standard version: + t.restart(); + for(i = 0; i < iter_count; ++i) + { + std::fill(c_array, c_array + array_size, (char)3); + } + result = t.elapsed(); + cout << "std::fill<char*, char>: " << result << endl << endl; + + cout << "testing fill(int)...\n" << endl; + + // cache load: + opt::fill(i_array, i_array + array_size, 3); + + // timer optimised version: + t.restart(); + for(i = 0; i < iter_count; ++i) + { + opt::fill(i_array, i_array + array_size, 3); + } + result = t.elapsed(); + cout << "opt::fill<int*, int>: " << result << endl; + + // cache load: + non_opt::fill(i_array, i_array + array_size, 3); + + // timer optimised version: + t.restart(); + for(i = 0; i < iter_count; ++i) + { + non_opt::fill(i_array, i_array + array_size, 3); + } + result = t.elapsed(); + cout << "non_opt::fill<int*, int>: " << result << endl; + + // cache load: + std::fill(i_array, i_array + array_size, 3); + + // time standard version: + t.restart(); + for(i = 0; i < iter_count; ++i) + { + std::fill(i_array, i_array + array_size, 3); + } + result = t.elapsed(); + cout << "std::fill<int*, int>: " << result << endl << endl; + + return 0; +} + + + + + + diff --git a/libs/type_traits/examples/iter_swap_example.cpp b/libs/type_traits/examples/iter_swap_example.cpp new file mode 100644 index 0000000000..a1f30f1d1c --- /dev/null +++ b/libs/type_traits/examples/iter_swap_example.cpp @@ -0,0 +1,97 @@ + +/* + * + * (C) Copyright John Maddock 1999-2005. + * 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) + * + * This file provides some example of type_traits usage - + * by "optimising" various algorithms: + * + * opt::iter_swap - uses type_traits to determine whether the iterator is a proxy + * in which case it uses a "safe" approach, otherwise calls swap + * on the assumption that swap may be specialised for the pointed-to type. + * + */ + +#include <iostream> +#include <typeinfo> +#include <algorithm> +#include <iterator> +#include <vector> +#include <memory> + +#include <boost/test/included/prg_exec_monitor.hpp> +#include <boost/type_traits.hpp> + +using std::cout; +using std::endl; +using std::cin; + +namespace opt{ + +// +// 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()); +} + + +}; // namespace opt + +int cpp_main(int argc, char* argv[]) +{ + // + // testing iter_swap + // really just a check that it does in fact compile... + std::vector<int> v1; + v1.push_back(0); + v1.push_back(1); + std::vector<bool> v2; + v2.push_back(0); + v2.push_back(1); + opt::iter_swap(v1.begin(), v1.begin()+1); + opt::iter_swap(v2.begin(), v2.begin()+1); + + return 0; +} + + + diff --git a/libs/type_traits/examples/trivial_destructor_example.cpp b/libs/type_traits/examples/trivial_destructor_example.cpp new file mode 100644 index 0000000000..49ee63ab69 --- /dev/null +++ b/libs/type_traits/examples/trivial_destructor_example.cpp @@ -0,0 +1,153 @@ + +/* + * + * (C) Copyright John Maddock 1999-2005. + * 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) + * + * This file provides some example of type_traits usage - + * by "optimising" various algorithms: + * + * opt::destroy_array - an example of optimisation based upon omitted destructor calls + * + */ + + +#include <iostream> +#include <boost/test/included/prg_exec_monitor.hpp> +#include <boost/timer.hpp> +#include <boost/type_traits.hpp> + +using std::cout; +using std::endl; +using std::cin; + +namespace opt{ + +// +// 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>()); +} + +// +// unoptimised versions of destroy_array: +// +template <class T> +void destroy_array1(T* first, T* last) +{ + while(first != last) + { + first->~T(); + ++first; + } +} +template <class T> +void destroy_array2(T* first, T* last) +{ + for(; first != last; ++first) first->~T(); +} + +} // namespace opt + +// +// define some global data: +// +const int array_size = 1000; +int i_array[array_size] = {0,}; +const int ci_array[array_size] = {0,}; +char c_array[array_size] = {0,}; +const char cc_array[array_size] = { 0,}; + +const int iter_count = 1000000; + + +int cpp_main(int argc, char* argv[]) +{ + boost::timer t; + double result; + int i; + // + // test destroy_array, + // compare destruction time of an array of ints + // with unoptimised form. + // + cout << "Measuring times in micro-seconds per 1000 elements processed" << endl << endl; + cout << "testing destroy_array...\n" + "[Some compilers may be able to optimise the \"unoptimised\"\n versions as well as type_traits does.]" << endl; + + // cache load: + opt::destroy_array(i_array, i_array + array_size); + + // time optimised version: + t.restart(); + for(i = 0; i < iter_count; ++i) + { + opt::destroy_array(i_array, i_array + array_size); + } + result = t.elapsed(); + cout << "destroy_array<int>: " << result << endl; + + // cache load: + opt::destroy_array1(i_array, i_array + array_size); + + // time unoptimised version #1: + t.restart(); + for(i = 0; i < iter_count; ++i) + { + opt::destroy_array1(i_array, i_array + array_size); + } + result = t.elapsed(); + cout << "destroy_array<int>(unoptimised#1): " << result << endl; + + // cache load: + opt::destroy_array2(i_array, i_array + array_size); + + // time unoptimised version #2: + t.restart(); + for(i = 0; i < iter_count; ++i) + { + opt::destroy_array2(i_array, i_array + array_size); + } + result = t.elapsed(); + cout << "destroy_array<int>(unoptimised#2): " << result << endl << endl; + + return 0; +} + + + + + + + + + + + diff --git a/libs/type_traits/index.html b/libs/type_traits/index.html new file mode 100644 index 0000000000..030742009e --- /dev/null +++ b/libs/type_traits/index.html @@ -0,0 +1,19 @@ +<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> +<html> + <head> + <meta http-equiv="refresh" content="0; URL=doc/html/index.html"> + </head> + <body> + <P>Automatic redirection failed, please go to + <a href="doc/html/index.html">doc/html/index.html</a>.</P> + <P>Copyright John Maddock 2001</P> + <P>Distributed under the Boost Software License, Version 1.0. (See accompanying file <A href="../../LICENSE_1_0.txt"> + LICENSE_1_0.txt</A> or copy at <A href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</A>).</P> + </body> +</html> + + + + + + diff --git a/libs/type_traits/test/Jamfile.v2 b/libs/type_traits/test/Jamfile.v2 new file mode 100644 index 0000000000..8f18a9b5f2 --- /dev/null +++ b/libs/type_traits/test/Jamfile.v2 @@ -0,0 +1,39 @@ +# copyright John Maddock 2004 +# 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) + +# bring in the rules for testing +import testing ; + +# type_traits in V1 seem to have two modes: standalone, triggered +# by a command line option, and a regular. For now, just imitate +# regular + +project : requirements + # default to all warnings on: + <warnings>all + # set warnings as errors for those compilers we know we get warning free: + <toolset>gcc:<cxxflags>-Wextra + <toolset>gcc:<cxxflags>-Wno-uninitialized + <toolset>gcc:<warnings-as-errors>on + <toolset>intel:<warnings-as-errors>on + <toolset>sun:<warnings-as-errors>on + <toolset>msvc:<warnings-as-errors>on +; + +rule all-tests { + local result ; + for local source in [ glob *_test.cpp ] udt_specialisations.cpp + { + result += [ run $(source) ] ; + } + return $(result) ; +} + +test-suite type_traits : [ all-tests ] ; + +compile-fail common_type_fail.cpp ; + + + diff --git a/libs/type_traits/test/add_const_test.cpp b/libs/type_traits/test/add_const_test.cpp new file mode 100644 index 0000000000..f61aef84ba --- /dev/null +++ b/libs/type_traits/test/add_const_test.cpp @@ -0,0 +1,61 @@ + +// (C) Copyright John Maddock 2000. +// 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" +#ifdef TEST_STD +# include <type_traits> +#else +# include <boost/type_traits/add_const.hpp> +#endif + +BOOST_DECL_TRANSFORM_TEST(add_const_test_1, ::tt::add_const, const, const) +BOOST_DECL_TRANSFORM_TEST(add_const_test_2, ::tt::add_const, volatile, volatile const) +BOOST_DECL_TRANSFORM_TEST(add_const_test_3, ::tt::add_const, *, *const) +BOOST_DECL_TRANSFORM_TEST2(add_const_test_4, ::tt::add_const, const) +BOOST_DECL_TRANSFORM_TEST(add_const_test_7, ::tt::add_const, *volatile, *volatile const) +BOOST_DECL_TRANSFORM_TEST(add_const_test_10, ::tt::add_const, const*, const*const) +BOOST_DECL_TRANSFORM_TEST(add_const_test_11, ::tt::add_const, volatile*, volatile*const) +BOOST_DECL_TRANSFORM_TEST(add_const_test_5, ::tt::add_const, const &, const&) +BOOST_DECL_TRANSFORM_TEST(add_const_test_6, ::tt::add_const, &, &) +#ifndef BOOST_NO_RVALUE_REFERENCES +BOOST_DECL_TRANSFORM_TEST(add_const_test_5a, ::tt::add_const, const &&, const&&) +BOOST_DECL_TRANSFORM_TEST(add_const_test_6a, ::tt::add_const, &&, &&) +#endif +BOOST_DECL_TRANSFORM_TEST(add_const_test_8, ::tt::add_const, const [2], const [2]) +BOOST_DECL_TRANSFORM_TEST(add_const_test_9, ::tt::add_const, volatile &, volatile&) +BOOST_DECL_TRANSFORM_TEST(add_const_test_12, ::tt::add_const, [2][3], const[2][3]) +BOOST_DECL_TRANSFORM_TEST(add_const_test_13, ::tt::add_const, (&)[2], (&)[2]) + +TT_TEST_BEGIN(add_const) + + add_const_test_1(); + add_const_test_2(); + add_const_test_3(); + add_const_test_4(); + add_const_test_7(); + add_const_test_10(); + add_const_test_11(); + add_const_test_5(); + add_const_test_6(); + add_const_test_8(); + add_const_test_9(); + add_const_test_12(); + add_const_test_13(); +#ifndef BOOST_NO_RVALUE_REFERENCES + add_const_test_5a(); + add_const_test_6a(); +#endif + +TT_TEST_END + + + + + + + + diff --git a/libs/type_traits/test/add_cv_test.cpp b/libs/type_traits/test/add_cv_test.cpp new file mode 100644 index 0000000000..45244a772e --- /dev/null +++ b/libs/type_traits/test/add_cv_test.cpp @@ -0,0 +1,61 @@ + +// (C) Copyright John Maddock 2005. +// 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" +#ifdef TEST_STD +# include <type_traits> +#else +# include <boost/type_traits/add_cv.hpp> +#endif + +BOOST_DECL_TRANSFORM_TEST(add_cv_test_1, ::tt::add_cv, const, const volatile) +BOOST_DECL_TRANSFORM_TEST(add_cv_test_2, ::tt::add_cv, volatile, volatile const) +BOOST_DECL_TRANSFORM_TEST(add_cv_test_3, ::tt::add_cv, *, *const volatile) +BOOST_DECL_TRANSFORM_TEST2(add_cv_test_4, ::tt::add_cv, const volatile) +BOOST_DECL_TRANSFORM_TEST(add_cv_test_7, ::tt::add_cv, *volatile, *volatile const) +BOOST_DECL_TRANSFORM_TEST(add_cv_test_10, ::tt::add_cv, const*, const*const volatile) +BOOST_DECL_TRANSFORM_TEST(add_cv_test_11, ::tt::add_cv, volatile*, volatile*const volatile ) +BOOST_DECL_TRANSFORM_TEST(add_cv_test_5, ::tt::add_cv, const &, const&) +BOOST_DECL_TRANSFORM_TEST(add_cv_test_6, ::tt::add_cv, &, &) +#ifndef BOOST_NO_RVALUE_REFERENCES +BOOST_DECL_TRANSFORM_TEST(add_cv_test_5a, ::tt::add_cv, const &&, const&&) +BOOST_DECL_TRANSFORM_TEST(add_cv_test_6a, ::tt::add_cv, &&, &&) +#endif +BOOST_DECL_TRANSFORM_TEST(add_cv_test_8, ::tt::add_cv, const [2], const volatile [2]) +BOOST_DECL_TRANSFORM_TEST(add_cv_test_9, ::tt::add_cv, volatile &, volatile&) +BOOST_DECL_TRANSFORM_TEST(add_cv_test_12, ::tt::add_cv, [2][3], const volatile[2][3]) +BOOST_DECL_TRANSFORM_TEST(add_cv_test_13, ::tt::add_cv, (&)[2], (&)[2]) + +TT_TEST_BEGIN(add_const) + + add_cv_test_1(); + add_cv_test_2(); + add_cv_test_3(); + add_cv_test_4(); + add_cv_test_7(); + add_cv_test_10(); + add_cv_test_11(); + add_cv_test_5(); + add_cv_test_6(); + add_cv_test_8(); + add_cv_test_9(); + add_cv_test_12(); + add_cv_test_13(); +#ifndef BOOST_NO_RVALUE_REFERENCES + add_cv_test_5a(); + add_cv_test_6a(); +#endif + +TT_TEST_END + + + + + + + + diff --git a/libs/type_traits/test/add_lvalue_reference_test.cpp b/libs/type_traits/test/add_lvalue_reference_test.cpp new file mode 100644 index 0000000000..18931b9fa3 --- /dev/null +++ b/libs/type_traits/test/add_lvalue_reference_test.cpp @@ -0,0 +1,63 @@ + +// (C) Copyright John Maddock 2000. +// 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" +#ifdef TEST_STD +# include <type_traits> +#else +# include <boost/type_traits/add_lvalue_reference.hpp> +#endif + +BOOST_DECL_TRANSFORM_TEST(add_lvalue_reference_test_1, ::tt::add_lvalue_reference, const, const&) +BOOST_DECL_TRANSFORM_TEST(add_lvalue_reference_test_2, ::tt::add_lvalue_reference, volatile, volatile&) +BOOST_DECL_TRANSFORM_TEST(add_lvalue_reference_test_3, ::tt::add_lvalue_reference, *, *&) +BOOST_DECL_TRANSFORM_TEST2(add_lvalue_reference_test_4, ::tt::add_lvalue_reference, &) +BOOST_DECL_TRANSFORM_TEST(add_lvalue_reference_test_5, ::tt::add_lvalue_reference, const &, const&) +BOOST_DECL_TRANSFORM_TEST(add_lvalue_reference_test_6, ::tt::add_lvalue_reference, &, &) +BOOST_DECL_TRANSFORM_TEST(add_lvalue_reference_test_7, ::tt::add_lvalue_reference, *volatile, *volatile&) +BOOST_DECL_TRANSFORM_TEST(add_lvalue_reference_test_8, ::tt::add_lvalue_reference, const [2], const (&)[2]) +BOOST_DECL_TRANSFORM_TEST(add_lvalue_reference_test_9, ::tt::add_lvalue_reference, const &, const&) +BOOST_DECL_TRANSFORM_TEST(add_lvalue_reference_test_10, ::tt::add_lvalue_reference, const*, const*&) +BOOST_DECL_TRANSFORM_TEST(add_lvalue_reference_test_11, ::tt::add_lvalue_reference, volatile*, volatile*&) +BOOST_DECL_TRANSFORM_TEST(add_lvalue_reference_test_12, ::tt::add_lvalue_reference, const[2][3], const (&)[2][3]) +BOOST_DECL_TRANSFORM_TEST(add_lvalue_reference_test_13, ::tt::add_lvalue_reference, (&)[2], (&)[2]) +#ifndef BOOST_NO_RVALUE_REFERENCES +BOOST_DECL_TRANSFORM_TEST(add_lvalue_reference_test_5a, ::tt::add_lvalue_reference, const &&, const&) +BOOST_DECL_TRANSFORM_TEST(add_lvalue_reference_test_6a, ::tt::add_lvalue_reference, &&, &) +BOOST_DECL_TRANSFORM_TEST(add_lvalue_reference_test_13a, ::tt::add_lvalue_reference, (&&)[2], (&)[2]) +#endif + +TT_TEST_BEGIN(add_lvalue_reference) + + add_lvalue_reference_test_1(); + add_lvalue_reference_test_2(); + add_lvalue_reference_test_3(); + add_lvalue_reference_test_4(); + add_lvalue_reference_test_5(); + add_lvalue_reference_test_6(); + add_lvalue_reference_test_7(); + add_lvalue_reference_test_8(); + add_lvalue_reference_test_9(); + add_lvalue_reference_test_10(); + add_lvalue_reference_test_11(); + add_lvalue_reference_test_12(); + add_lvalue_reference_test_13(); +#ifndef BOOST_NO_RVALUE_REFERENCES + add_lvalue_reference_test_5a(); + add_lvalue_reference_test_6a(); + add_lvalue_reference_test_13a(); +#endif + +TT_TEST_END + + + + + + + + diff --git a/libs/type_traits/test/add_pointer_test.cpp b/libs/type_traits/test/add_pointer_test.cpp new file mode 100644 index 0000000000..3b52eda7f7 --- /dev/null +++ b/libs/type_traits/test/add_pointer_test.cpp @@ -0,0 +1,41 @@ + +// (C) Copyright John Maddock 2000. +// 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" +#ifdef TEST_STD +# include <type_traits> +#else +# include <boost/type_traits/add_pointer.hpp> +#endif + +BOOST_DECL_TRANSFORM_TEST(add_pointer_test_1, ::tt::add_pointer, const, const*) +BOOST_DECL_TRANSFORM_TEST(add_pointer_test_2, ::tt::add_pointer, volatile, volatile*) +BOOST_DECL_TRANSFORM_TEST(add_pointer_test_3, ::tt::add_pointer, *, **) +BOOST_DECL_TRANSFORM_TEST2(add_pointer_test_4, ::tt::add_pointer, *) +BOOST_DECL_TRANSFORM_TEST(add_pointer_test_7, ::tt::add_pointer, *volatile, *volatile*) +BOOST_DECL_TRANSFORM_TEST(add_pointer_test_10, ::tt::add_pointer, const*, const**) +BOOST_DECL_TRANSFORM_TEST(add_pointer_test_11, ::tt::add_pointer, volatile*, volatile**) + +TT_TEST_BEGIN(add_pointer) + + add_pointer_test_1(); + add_pointer_test_2(); + add_pointer_test_3(); + add_pointer_test_4(); + add_pointer_test_7(); + add_pointer_test_10(); + add_pointer_test_11(); + +TT_TEST_END + + + + + + + + diff --git a/libs/type_traits/test/add_reference_test.cpp b/libs/type_traits/test/add_reference_test.cpp new file mode 100644 index 0000000000..5e47dd2bbc --- /dev/null +++ b/libs/type_traits/test/add_reference_test.cpp @@ -0,0 +1,63 @@ + +// (C) Copyright John Maddock 2000. +// 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" +#ifdef TEST_STD +# include <type_traits> +#else +# include <boost/type_traits/add_reference.hpp> +#endif + +BOOST_DECL_TRANSFORM_TEST(add_reference_test_1, ::tt::add_reference, const, const&) +BOOST_DECL_TRANSFORM_TEST(add_reference_test_2, ::tt::add_reference, volatile, volatile&) +BOOST_DECL_TRANSFORM_TEST(add_reference_test_3, ::tt::add_reference, *, *&) +BOOST_DECL_TRANSFORM_TEST2(add_reference_test_4, ::tt::add_reference, &) +BOOST_DECL_TRANSFORM_TEST(add_reference_test_5, ::tt::add_reference, const &, const&) +BOOST_DECL_TRANSFORM_TEST(add_reference_test_6, ::tt::add_reference, &, &) +BOOST_DECL_TRANSFORM_TEST(add_reference_test_7, ::tt::add_reference, *volatile, *volatile&) +BOOST_DECL_TRANSFORM_TEST(add_reference_test_8, ::tt::add_reference, const [2], const (&)[2]) +BOOST_DECL_TRANSFORM_TEST(add_reference_test_9, ::tt::add_reference, const &, const&) +BOOST_DECL_TRANSFORM_TEST(add_reference_test_10, ::tt::add_reference, const*, const*&) +BOOST_DECL_TRANSFORM_TEST(add_reference_test_11, ::tt::add_reference, volatile*, volatile*&) +BOOST_DECL_TRANSFORM_TEST(add_reference_test_12, ::tt::add_reference, const[2][3], const (&)[2][3]) +BOOST_DECL_TRANSFORM_TEST(add_reference_test_13, ::tt::add_reference, (&)[2], (&)[2]) +#ifndef BOOST_NO_RVALUE_REFERENCES +BOOST_DECL_TRANSFORM_TEST(add_reference_test_5a, ::tt::add_reference, const &&, const&&) +BOOST_DECL_TRANSFORM_TEST(add_reference_test_6a, ::tt::add_reference, &&, &&) +BOOST_DECL_TRANSFORM_TEST(add_reference_test_13a, ::tt::add_reference, (&&)[2], (&&)[2]) +#endif + +TT_TEST_BEGIN(add_reference) + + add_reference_test_1(); + add_reference_test_2(); + add_reference_test_3(); + add_reference_test_4(); + add_reference_test_5(); + add_reference_test_6(); + add_reference_test_7(); + add_reference_test_8(); + add_reference_test_9(); + add_reference_test_10(); + add_reference_test_11(); + add_reference_test_12(); + add_reference_test_13(); +#ifndef BOOST_NO_RVALUE_REFERENCES + add_reference_test_5a(); + add_reference_test_6a(); + add_reference_test_13a(); +#endif + +TT_TEST_END + + + + + + + + diff --git a/libs/type_traits/test/add_rvalue_reference_test.cpp b/libs/type_traits/test/add_rvalue_reference_test.cpp new file mode 100644 index 0000000000..8527094e4f --- /dev/null +++ b/libs/type_traits/test/add_rvalue_reference_test.cpp @@ -0,0 +1,80 @@ + +// Copyright 2010 Vicente J. Botet Escriba +// 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 "../../type_traits/test/test.hpp" +#include "../../type_traits/test/check_type.hpp" +#ifdef TEST_STD +# include <type_traits> +#else +# include <boost/type_traits/add_rvalue_reference.hpp> +#endif + +#ifdef BOOST_NO_RVALUE_REFERENCES + +BOOST_DECL_TRANSFORM_TEST(add_rvalue_reference_test_1, ::tt::add_rvalue_reference, const, const) +BOOST_DECL_TRANSFORM_TEST(add_rvalue_reference_test_2, ::tt::add_rvalue_reference, volatile, volatile) +BOOST_DECL_TRANSFORM_TEST(add_rvalue_reference_test_3, ::tt::add_rvalue_reference, *, *) +BOOST_DECL_TRANSFORM_TEST0(add_rvalue_reference_test_4, ::tt::add_rvalue_reference) +BOOST_DECL_TRANSFORM_TEST(add_rvalue_reference_test_5, ::tt::add_rvalue_reference, const &, const&) +BOOST_DECL_TRANSFORM_TEST(add_rvalue_reference_test_6, ::tt::add_rvalue_reference, &, &) +BOOST_DECL_TRANSFORM_TEST(add_rvalue_reference_test_7, ::tt::add_rvalue_reference, *volatile, *volatile) +BOOST_DECL_TRANSFORM_TEST(add_rvalue_reference_test_8, ::tt::add_rvalue_reference, const [2], const [2]) +BOOST_DECL_TRANSFORM_TEST(add_rvalue_reference_test_9, ::tt::add_rvalue_reference, const &, const&) +BOOST_DECL_TRANSFORM_TEST(add_rvalue_reference_test_10, ::tt::add_rvalue_reference, const*, const*) +BOOST_DECL_TRANSFORM_TEST(add_rvalue_reference_test_11, ::tt::add_rvalue_reference, volatile*, volatile*) +BOOST_DECL_TRANSFORM_TEST(add_rvalue_reference_test_12, ::tt::add_rvalue_reference, const[2][3], const [2][3]) +BOOST_DECL_TRANSFORM_TEST(add_rvalue_reference_test_13, ::tt::add_rvalue_reference, (&)[2], (&)[2]) +#else + +BOOST_DECL_TRANSFORM_TEST(add_rvalue_reference_test_1, ::tt::add_rvalue_reference, const, const&&) +BOOST_DECL_TRANSFORM_TEST(add_rvalue_reference_test_2, ::tt::add_rvalue_reference, volatile, volatile&&) +BOOST_DECL_TRANSFORM_TEST(add_rvalue_reference_test_3, ::tt::add_rvalue_reference, *, *&&) +BOOST_DECL_TRANSFORM_TEST2(add_rvalue_reference_test_4, ::tt::add_rvalue_reference, &&) +BOOST_DECL_TRANSFORM_TEST(add_rvalue_reference_test_5, ::tt::add_rvalue_reference, const &, const&) +BOOST_DECL_TRANSFORM_TEST(add_rvalue_reference_test_6, ::tt::add_rvalue_reference, &, &) +BOOST_DECL_TRANSFORM_TEST(add_rvalue_reference_test_7, ::tt::add_rvalue_reference, *volatile, *volatile&&) +BOOST_DECL_TRANSFORM_TEST(add_rvalue_reference_test_8, ::tt::add_rvalue_reference, const [2], const (&&) [2]) +BOOST_DECL_TRANSFORM_TEST(add_rvalue_reference_test_9, ::tt::add_rvalue_reference, const &, const&) +BOOST_DECL_TRANSFORM_TEST(add_rvalue_reference_test_10, ::tt::add_rvalue_reference, const*, const*&&) +BOOST_DECL_TRANSFORM_TEST(add_rvalue_reference_test_11, ::tt::add_rvalue_reference, volatile*, volatile*&&) +BOOST_DECL_TRANSFORM_TEST(add_rvalue_reference_test_12, ::tt::add_rvalue_reference, const[2][3], const (&&) [2][3]) +BOOST_DECL_TRANSFORM_TEST(add_rvalue_reference_test_13, ::tt::add_rvalue_reference, (&)[2], (&)[2]) + +BOOST_DECL_TRANSFORM_TEST(add_rvalue_reference_test_5a, ::tt::add_rvalue_reference, const &&, const&&) +BOOST_DECL_TRANSFORM_TEST(add_rvalue_reference_test_6a, ::tt::add_rvalue_reference, &&, &&) +BOOST_DECL_TRANSFORM_TEST(add_rvalue_reference_test_13a, ::tt::add_rvalue_reference, (&&)[2], (&&)[2]) +#endif + +TT_TEST_BEGIN(add_rvalue_reference) + + add_rvalue_reference_test_1(); + add_rvalue_reference_test_2(); + add_rvalue_reference_test_3(); + add_rvalue_reference_test_4(); + add_rvalue_reference_test_5(); + add_rvalue_reference_test_6(); + add_rvalue_reference_test_7(); + add_rvalue_reference_test_8(); + add_rvalue_reference_test_9(); + add_rvalue_reference_test_10(); + add_rvalue_reference_test_11(); + add_rvalue_reference_test_12(); + add_rvalue_reference_test_13(); +#ifndef BOOST_NO_RVALUE_REFERENCES + add_rvalue_reference_test_5a(); + add_rvalue_reference_test_6a(); + add_rvalue_reference_test_13a(); +#endif + +TT_TEST_END + + + + + + + + diff --git a/libs/type_traits/test/add_volatile_test.cpp b/libs/type_traits/test/add_volatile_test.cpp new file mode 100644 index 0000000000..a9d5161029 --- /dev/null +++ b/libs/type_traits/test/add_volatile_test.cpp @@ -0,0 +1,59 @@ + +// (C) Copyright John Maddock 2000. +// 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" +#ifdef TEST_STD +# include <type_traits> +#else +# include <boost/type_traits/add_volatile.hpp> +#endif + +BOOST_DECL_TRANSFORM_TEST(add_volatile_test_1, ::tt::add_volatile, const, const volatile) +BOOST_DECL_TRANSFORM_TEST(add_volatile_test_2, ::tt::add_volatile, volatile, volatile) +BOOST_DECL_TRANSFORM_TEST(add_volatile_test_3, ::tt::add_volatile, *, *volatile) +BOOST_DECL_TRANSFORM_TEST2(add_volatile_test_4, ::tt::add_volatile, volatile) +BOOST_DECL_TRANSFORM_TEST(add_volatile_test_7, ::tt::add_volatile, *volatile, *volatile) +BOOST_DECL_TRANSFORM_TEST(add_volatile_test_10, ::tt::add_volatile, const*, const*volatile) +BOOST_DECL_TRANSFORM_TEST(add_volatile_test_11, ::tt::add_volatile, volatile*, volatile*volatile) +BOOST_DECL_TRANSFORM_TEST(add_volatile_test_5, ::tt::add_volatile, const &, const&) +BOOST_DECL_TRANSFORM_TEST(add_volatile_test_6, ::tt::add_volatile, &, &) +#ifndef BOOST_NO_RVALUE_REFERENCES +BOOST_DECL_TRANSFORM_TEST(add_volatile_test_6a, ::tt::add_volatile, &&, &&) +#endif +BOOST_DECL_TRANSFORM_TEST(add_volatile_test_8, ::tt::add_volatile, const [2], const volatile [2]) +BOOST_DECL_TRANSFORM_TEST(add_volatile_test_9, ::tt::add_volatile, volatile &, volatile&) +BOOST_DECL_TRANSFORM_TEST(add_volatile_test_12, ::tt::add_volatile, [2][3], volatile[2][3]) +BOOST_DECL_TRANSFORM_TEST(add_volatile_test_13, ::tt::add_volatile, (&)[2], (&)[2]) + +TT_TEST_BEGIN(add_volatile) + + add_volatile_test_1(); + add_volatile_test_2(); + add_volatile_test_3(); + add_volatile_test_4(); + add_volatile_test_7(); + add_volatile_test_10(); + add_volatile_test_11(); + add_volatile_test_5(); + add_volatile_test_6(); + add_volatile_test_8(); + add_volatile_test_9(); + add_volatile_test_12(); + add_volatile_test_13(); +#ifndef BOOST_NO_RVALUE_REFERENCES + add_volatile_test_6a(); +#endif + +TT_TEST_END + + + + + + + + diff --git a/libs/type_traits/test/aligned_storage_empy_test.cpp b/libs/type_traits/test/aligned_storage_empy_test.cpp new file mode 100644 index 0000000000..536b06dc78 --- /dev/null +++ b/libs/type_traits/test/aligned_storage_empy_test.cpp @@ -0,0 +1,128 @@ + +// (C) Copyright Thorsten Ottosen 2009. +// 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> +# include <boost/type_traits/type_with_alignment.hpp> // max_align and long_long_type +#else +# include <boost/type_traits/alignment_of.hpp> +# include <boost/type_traits/aligned_storage.hpp> +# include <boost/type_traits/is_pod.hpp> +#endif + + +namespace +{ + template< unsigned N, unsigned Alignment > + struct alignment_implementation1 + { + boost::detail::aligned_storage::aligned_storage_imp<N,Alignment> type; + const void* address() const { return type.address(); } + }; + + template< unsigned N, unsigned Alignment > + struct alignment_implementation2 : +#ifndef __BORLANDC__ + private +#else + public +#endif + boost::detail::aligned_storage::aligned_storage_imp<N,Alignment> + { + typedef boost::detail::aligned_storage::aligned_storage_imp<N,Alignment> type; + const void* address() const { return static_cast<const type*>(this)->address(); } + }; + + template< unsigned N, class T > + std::ptrdiff_t get_address1() + { + static alignment_implementation1<N*sizeof(T), tt::alignment_of<T>::value> imp1; + return static_cast<const char*>(imp1.address()) - reinterpret_cast<const char*>(&imp1); + } + + template< unsigned N, class T > + std::ptrdiff_t get_address2() + { + static alignment_implementation2<N*sizeof(T), tt::alignment_of<T>::value> imp2; + return static_cast<const char*>(imp2.address()) - reinterpret_cast<const char*>(&imp2); + } + + template< class T > + void do_check() + { + std::ptrdiff_t addr1 = get_address1<0,T>(); + std::ptrdiff_t addr2 = get_address2<0,T>(); + // + // @remark: only the empty case differs + // + BOOST_CHECK( addr1 != addr2 ); + + addr1 = get_address1<1,T>(); + addr2 = get_address2<1,T>(); + BOOST_CHECK( addr1 == addr2 ); + + addr1 = get_address1<2,T>(); + addr2 = get_address2<2,T>(); + BOOST_CHECK( addr1 == addr2 ); + + addr1 = get_address1<3,T>(); + addr2 = get_address2<3,T>(); + BOOST_CHECK( addr1 == addr2 ); + + addr1 = get_address1<4,T>(); + addr2 = get_address2<4,T>(); + BOOST_CHECK( addr1 == addr2 ); + + addr1 = get_address1<17,T>(); + addr2 = get_address2<17,T>(); + BOOST_CHECK( addr1 == addr2 ); + + addr1 = get_address1<32,T>(); + addr2 = get_address2<32,T>(); + BOOST_CHECK( addr1 == addr2 ); + } +} + +TT_TEST_BEGIN(type_with_empty_alignment_buffer) + +do_check<char>(); +do_check<short>(); +do_check<int>(); +do_check<long>(); +do_check<float>(); +do_check<double>(); +do_check<long double>(); + +#ifdef BOOST_HAS_MS_INT64 +do_check<__int64>(); +#endif +#ifdef BOOST_HAS_LONG_LONG +do_check<boost::long_long_type>(); +#endif + +do_check<int(*)(int)>(); +do_check<int*>(); +do_check<VB>(); +do_check<VD>(); +do_check<enum_UDT>(); +do_check<mf2>(); +do_check<POD_UDT>(); +do_check<empty_UDT>(); +do_check<union_UDT>(); +do_check<boost::detail::max_align>(); + +TT_TEST_END + + + + + + + + + diff --git a/libs/type_traits/test/aligned_storage_test.cpp b/libs/type_traits/test/aligned_storage_test.cpp new file mode 100644 index 0000000000..496ae2cf9f --- /dev/null +++ b/libs/type_traits/test/aligned_storage_test.cpp @@ -0,0 +1,116 @@ + +// (C) Copyright John Maddock 2000. +// 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> +# include <boost/type_traits/type_with_alignment.hpp> // max_align and long_long_type +#else +# include <boost/type_traits/alignment_of.hpp> +# include <boost/type_traits/aligned_storage.hpp> +# include <boost/type_traits/is_pod.hpp> +#endif + +template <class T> +union must_be_pod +{ + int i; + T t; +}; + +template <class T> +inline void no_unused_warning(const volatile T&) +{ +} + +#if defined(__GNUC__) && (__GNUC__ >= 4) && !defined(BOOST_INTEL) +#pragma GCC diagnostic ignored "-Wmissing-braces" +#endif + +template <class T> +void do_check(const T&) +{ + typedef typename tt::aligned_storage<T::value,T::value>::type t1; + t1 as1 = { 0, }; + must_be_pod<t1> pod1; + no_unused_warning(as1); + no_unused_warning(pod1); + BOOST_TEST_MESSAGE(typeid(t1).name()); + BOOST_CHECK(::tt::alignment_of<t1>::value == T::value); + BOOST_CHECK(sizeof(t1) == T::value); +#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + BOOST_CHECK(::tt::is_pod<t1>::value == true); +#endif + typedef typename tt::aligned_storage<T::value*2,T::value>::type t2; + t2 as2 = { 0, }; + must_be_pod<t2> pod2; + no_unused_warning(as2); + no_unused_warning(pod2); + BOOST_TEST_MESSAGE(typeid(t2).name()); + BOOST_CHECK(::tt::alignment_of<t2>::value == T::value); + BOOST_CHECK(sizeof(t2) == T::value*2); +#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + BOOST_CHECK(::tt::is_pod<t2>::value == true); +#endif + +#ifndef TEST_STD + // Non-Tr1 behaviour: + typedef typename tt::aligned_storage<T::value, ~static_cast<std::size_t>(0UL)>::type t3; + t3 as3 = { 0, }; + must_be_pod<t3> pod3; + no_unused_warning(as3); + no_unused_warning(pod3); + BOOST_TEST_MESSAGE(typeid(t3).name()); + BOOST_CHECK(::tt::alignment_of<t3>::value == ::tt::alignment_of< ::boost::detail::max_align>::value); + BOOST_CHECK((sizeof(t3) % T::value) == 0); +#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + BOOST_CHECK(::tt::is_pod<t3>::value == true); +#endif + BOOST_CHECK(as3.address() == &as3); + const t3 as4 = { 0, }; + BOOST_CHECK(as4.address() == static_cast<const void*>(&as4)); +#endif +} + +TT_TEST_BEGIN(type_with_alignment) + +do_check(tt::integral_constant<std::size_t,::tt::alignment_of<char>::value>()); +do_check(tt::integral_constant<std::size_t,::tt::alignment_of<short>::value>()); +do_check(tt::integral_constant<std::size_t,::tt::alignment_of<int>::value>()); +do_check(tt::integral_constant<std::size_t,::tt::alignment_of<long>::value>()); +do_check(tt::integral_constant<std::size_t,::tt::alignment_of<float>::value>()); +do_check(tt::integral_constant<std::size_t,::tt::alignment_of<double>::value>()); +do_check(tt::integral_constant<std::size_t,::tt::alignment_of<long double>::value>()); + +#ifdef BOOST_HAS_LONG_LONG +do_check(tt::integral_constant<std::size_t,::tt::alignment_of< ::boost::long_long_type>::value>()); +#endif +#ifdef BOOST_HAS_MS_INT64 +do_check(tt::integral_constant<std::size_t,::tt::alignment_of<__int64>::value>()); +#endif +do_check(tt::integral_constant<std::size_t,::tt::alignment_of<int[4]>::value>()); +do_check(tt::integral_constant<std::size_t,::tt::alignment_of<int(*)(int)>::value>()); +do_check(tt::integral_constant<std::size_t,::tt::alignment_of<int*>::value>()); +do_check(tt::integral_constant<std::size_t,::tt::alignment_of<VB>::value>()); +do_check(tt::integral_constant<std::size_t,::tt::alignment_of<VD>::value>()); +do_check(tt::integral_constant<std::size_t,::tt::alignment_of<enum_UDT>::value>()); +do_check(tt::integral_constant<std::size_t,::tt::alignment_of<mf2>::value>()); +do_check(tt::integral_constant<std::size_t,::tt::alignment_of<POD_UDT>::value>()); +do_check(tt::integral_constant<std::size_t,::tt::alignment_of<empty_UDT>::value>()); +do_check(tt::integral_constant<std::size_t,::tt::alignment_of<union_UDT>::value>()); +do_check(tt::integral_constant<std::size_t,::tt::alignment_of<boost::detail::max_align>::value>()); + +TT_TEST_END + + + + + + + + + diff --git a/libs/type_traits/test/aligned_storage_test_a2.cpp b/libs/type_traits/test/aligned_storage_test_a2.cpp new file mode 100644 index 0000000000..fa7360dbff --- /dev/null +++ b/libs/type_traits/test/aligned_storage_test_a2.cpp @@ -0,0 +1,113 @@ + +#ifdef _MSC_VER +#pragma pack(2) +#endif + +// (C) Copyright John Maddock 2000. +// 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> +# include <boost/type_traits/type_with_alignment.hpp> // max_align and long_long_type +#else +# include <boost/type_traits/alignment_of.hpp> +# include <boost/type_traits/aligned_storage.hpp> +# include <boost/type_traits/is_pod.hpp> +#endif + +template <class T> +union must_be_pod +{ + int i; + T t; +}; + +template <class T> +inline void no_unused_warning(const volatile T&) +{ +} + +template <class T> +void do_check(const T&) +{ + typedef typename tt::aligned_storage<T::value,T::value>::type t1; + t1 as1 = { 0, }; + must_be_pod<t1> pod1; + no_unused_warning(as1); + no_unused_warning(pod1); + BOOST_TEST_MESSAGE(typeid(t1).name()); + BOOST_CHECK(::tt::alignment_of<t1>::value == T::value); + BOOST_CHECK(sizeof(t1) == T::value); +#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + BOOST_CHECK(::tt::is_pod<t1>::value == true); +#endif + typedef typename tt::aligned_storage<T::value*2,T::value>::type t2; + t2 as2 = { 0, }; + must_be_pod<t2> pod2; + no_unused_warning(as2); + no_unused_warning(pod2); + BOOST_TEST_MESSAGE(typeid(t2).name()); + BOOST_CHECK(::tt::alignment_of<t2>::value == T::value); + BOOST_CHECK(sizeof(t2) == T::value*2); +#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + BOOST_CHECK(::tt::is_pod<t2>::value == true); +#endif + +#ifndef TEST_STD + // Non-Tr1 behaviour: + typedef typename tt::aligned_storage<T::value,-1L>::type t3; + t3 as3 = { 0, }; + must_be_pod<t3> pod3; + no_unused_warning(as3); + no_unused_warning(pod3); + BOOST_TEST_MESSAGE(typeid(t3).name()); + BOOST_CHECK(::tt::alignment_of<t3>::value == ::tt::alignment_of< ::boost::detail::max_align>::value); + BOOST_CHECK((sizeof(t3) % T::value) == 0); +#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + BOOST_CHECK(::tt::is_pod<t3>::value == true); +#endif +#endif +} + +TT_TEST_BEGIN(type_with_alignment) + +do_check(tt::integral_constant<std::size_t,::tt::alignment_of<char>::value>()); +do_check(tt::integral_constant<std::size_t,::tt::alignment_of<short>::value>()); +do_check(tt::integral_constant<std::size_t,::tt::alignment_of<int>::value>()); +do_check(tt::integral_constant<std::size_t,::tt::alignment_of<long>::value>()); +do_check(tt::integral_constant<std::size_t,::tt::alignment_of<float>::value>()); +do_check(tt::integral_constant<std::size_t,::tt::alignment_of<double>::value>()); +do_check(tt::integral_constant<std::size_t,::tt::alignment_of<long double>::value>()); + +#ifdef BOOST_HAS_LONG_LONG +do_check(tt::integral_constant<std::size_t,::tt::alignment_of< ::boost::long_long_type>::value>()); +#endif +#ifdef BOOST_HAS_MS_INT64 +do_check(tt::integral_constant<std::size_t,::tt::alignment_of<__int64>::value>()); +#endif +do_check(tt::integral_constant<std::size_t,::tt::alignment_of<int[4]>::value>()); +do_check(tt::integral_constant<std::size_t,::tt::alignment_of<int(*)(int)>::value>()); +do_check(tt::integral_constant<std::size_t,::tt::alignment_of<int*>::value>()); +do_check(tt::integral_constant<std::size_t,::tt::alignment_of<VB>::value>()); +do_check(tt::integral_constant<std::size_t,::tt::alignment_of<VD>::value>()); +do_check(tt::integral_constant<std::size_t,::tt::alignment_of<enum_UDT>::value>()); +do_check(tt::integral_constant<std::size_t,::tt::alignment_of<mf2>::value>()); +do_check(tt::integral_constant<std::size_t,::tt::alignment_of<POD_UDT>::value>()); +do_check(tt::integral_constant<std::size_t,::tt::alignment_of<empty_UDT>::value>()); +do_check(tt::integral_constant<std::size_t,::tt::alignment_of<union_UDT>::value>()); +do_check(tt::integral_constant<std::size_t,::tt::alignment_of<boost::detail::max_align>::value>()); + +TT_TEST_END + + + + + + + + + diff --git a/libs/type_traits/test/alignment_of_a2_test.cpp b/libs/type_traits/test/alignment_of_a2_test.cpp new file mode 100644 index 0000000000..fe6b66ebbf --- /dev/null +++ b/libs/type_traits/test/alignment_of_a2_test.cpp @@ -0,0 +1,126 @@ + +#ifdef _MSC_VER +#pragma pack(2) +#endif + +// (C) Copyright John Maddock 2000. +// 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/alignment_of.hpp> +#endif + +// +// Need to defined some member functions for empty_UDT, +// we don't want to put these in the test.hpp as that +// causes overly-clever compilers to figure out that they can't throw +// which in turn breaks other tests. +// +empty_UDT::empty_UDT(){} +empty_UDT::~empty_UDT(){} +empty_UDT::empty_UDT(const empty_UDT&){} +empty_UDT& empty_UDT::operator=(const empty_UDT&){ return *this; } +bool empty_UDT::operator==(const empty_UDT&)const{ return true; } + + +// +// VC++ emits an awful lot of warnings unless we define these: +#ifdef BOOST_MSVC +# pragma warning(disable:4244 4121) +// +// What follows here is the test case for issue 1946. +// +#include <boost/function.hpp> +// This kind of packing is set within MSVC 9.0 headers. +// E.g. std::ostream has it. +#pragma pack(push,8) + +// The issue is gone if Root has no data members +struct Root { int a; }; +// The issue is gone if Root is inherited non-virtually +struct A : virtual public Root {}; + +#pragma pack(pop) +// +// This class has 8-byte alignment but is 44 bytes in size, which means +// that elements in an array of this type will not actually be 8 byte +// aligned. This appears to be an MSVC bug, and throws off our +// alignment calculations: causing us to report a non-sensical 12-byte +// alignment for this type. This is fixed by using the native __alignof +// operator. +// +class issue1946 : + public A +{ +public: + // The issue is gone if the type is not a boost::function. The signature doesn't matter. + typedef boost::function0< void > function_type; + function_type m_function; +}; + +#endif + + +template <class T> +struct align_calc +{ + char padding; + T instance; + static std::ptrdiff_t get() + { + static align_calc<T> a; + return reinterpret_cast<const char*>(&(a.instance)) - reinterpret_cast<const char*>(&(a.padding)); + } +}; + +#define ALIGNOF(x) align_calc< x>::get() + +TT_TEST_BEGIN(alignment_of) + +#ifndef TEST_STD +// This test is not required to work for non-boost implementations: +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::alignment_of<void>::value, 0); +#endif +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::alignment_of<char>::value, ALIGNOF(char)); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::alignment_of<short>::value, ALIGNOF(short)); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::alignment_of<int>::value, ALIGNOF(int)); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::alignment_of<long>::value, ALIGNOF(long)); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::alignment_of<float>::value, ALIGNOF(float)); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::alignment_of<double>::value, ALIGNOF(double)); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::alignment_of<long double>::value, ALIGNOF(long double)); +#ifdef BOOST_HAS_LONG_LONG +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::alignment_of< ::boost::long_long_type>::value, ALIGNOF(::boost::long_long_type)); +#endif +#ifdef BOOST_HAS_MS_INT64 +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::alignment_of<__int64>::value, ALIGNOF(__int64)); +#endif +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::alignment_of<int[4]>::value, ALIGNOF(int[4])); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::alignment_of<int(*)(int)>::value, ALIGNOF(int(*)(int))); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::alignment_of<int*>::value, ALIGNOF(int*)); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::alignment_of<VB>::value, ALIGNOF(VB)); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::alignment_of<VD>::value, ALIGNOF(VD)); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::alignment_of<enum_UDT>::value, ALIGNOF(enum_UDT)); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::alignment_of<mf2>::value, ALIGNOF(mf2)); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::alignment_of<POD_UDT>::value, ALIGNOF(POD_UDT)); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::alignment_of<empty_UDT>::value, ALIGNOF(empty_UDT)); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::alignment_of<union_UDT>::value, ALIGNOF(union_UDT)); + +#if defined(BOOST_MSVC) && (BOOST_MSVC >= 1400) +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::alignment_of<issue1946>::value, ALIGNOF(issue1946)); +#endif + +TT_TEST_END + + + + + + + + diff --git a/libs/type_traits/test/alignment_of_test.cpp b/libs/type_traits/test/alignment_of_test.cpp new file mode 100644 index 0000000000..7faaf84d75 --- /dev/null +++ b/libs/type_traits/test/alignment_of_test.cpp @@ -0,0 +1,121 @@ + +// (C) Copyright John Maddock 2000. +// 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/alignment_of.hpp> +#endif + +// +// Need to defined some member function for empty_UDT, +// we don't want to put these in the test.hpp as that +// causes overly-clever compilers to figure out that they can't throw +// which in turn breaks other tests. +// +empty_UDT::empty_UDT(){} +empty_UDT::~empty_UDT(){} +empty_UDT::empty_UDT(const empty_UDT&){} +empty_UDT& empty_UDT::operator=(const empty_UDT&){ return *this; } +bool empty_UDT::operator==(const empty_UDT&)const{ return true; } + +// +// VC++ emits an awful lot of warnings unless we define these: +#ifdef BOOST_MSVC +# pragma warning(disable:4244) +// +// What follows here is the test case for issue 1946. +// +#include <boost/function.hpp> +// This kind of packing is set within MSVC 9.0 headers. +// E.g. std::ostream has it. +#pragma pack(push,8) + +// The issue is gone if Root has no data members +struct Root { int a; }; +// The issue is gone if Root is inherited non-virtually +struct A : virtual public Root {}; + +#pragma pack(pop) +// +// This class has 8-byte alignment but is 44 bytes in size, which means +// that elements in an array of this type will not actually be 8 byte +// aligned. This appears to be an MSVC bug, and throws off our +// alignment calculations: causing us to report a non-sensical 12-byte +// alignment for this type. This is fixed by using the native __alignof +// operator. +// +class issue1946 : + public A +{ +public: + // The issue is gone if the type is not a boost::function. The signature doesn't matter. + typedef boost::function0< void > function_type; + function_type m_function; +}; + +#endif + + +template <class T> +struct align_calc +{ + char padding; + T instance; + static std::ptrdiff_t get() + { + static align_calc<T> a; + return reinterpret_cast<const char*>(&(a.instance)) - reinterpret_cast<const char*>(&(a.padding)); + } +}; + +#define ALIGNOF(x) align_calc< x>::get() + +TT_TEST_BEGIN(alignment_of) + +#ifndef TEST_STD +// This test is not required to work for non-boost implementations: +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::alignment_of<void>::value, 0); +#endif +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::alignment_of<char>::value, ALIGNOF(char)); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::alignment_of<short>::value, ALIGNOF(short)); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::alignment_of<int>::value, ALIGNOF(int)); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::alignment_of<long>::value, ALIGNOF(long)); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::alignment_of<float>::value, ALIGNOF(float)); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::alignment_of<double>::value, ALIGNOF(double)); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::alignment_of<long double>::value, ALIGNOF(long double)); +#ifdef BOOST_HAS_LONG_LONG +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::alignment_of< ::boost::long_long_type>::value, ALIGNOF(::boost::long_long_type)); +#endif +#ifdef BOOST_HAS_MS_INT64 +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::alignment_of<__int64>::value, ALIGNOF(__int64)); +#endif +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::alignment_of<int[4]>::value, ALIGNOF(int[4])); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::alignment_of<int(*)(int)>::value, ALIGNOF(int(*)(int))); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::alignment_of<int*>::value, ALIGNOF(int*)); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::alignment_of<VB>::value, ALIGNOF(VB)); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::alignment_of<VD>::value, ALIGNOF(VD)); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::alignment_of<enum_UDT>::value, ALIGNOF(enum_UDT)); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::alignment_of<mf2>::value, ALIGNOF(mf2)); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::alignment_of<POD_UDT>::value, ALIGNOF(POD_UDT)); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::alignment_of<empty_UDT>::value, ALIGNOF(empty_UDT)); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::alignment_of<union_UDT>::value, ALIGNOF(union_UDT)); + +#if defined(BOOST_MSVC) && (BOOST_MSVC >= 1400) +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::alignment_of<issue1946>::value, ALIGNOF(issue1946)); +#endif + +TT_TEST_END + + + + + + + + diff --git a/libs/type_traits/test/check_integral_constant.hpp b/libs/type_traits/test/check_integral_constant.hpp new file mode 100644 index 0000000000..754a170c80 --- /dev/null +++ b/libs/type_traits/test/check_integral_constant.hpp @@ -0,0 +1,83 @@ + +// (C) Copyright John Maddock 2000. +// 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) + +#ifndef BOOST_CHECK_INTEGRAL_CONSTANT_HPP +#define BOOST_CHECK_INTEGRAL_CONSTANT_HPP + +#ifdef USE_UNIT_TEST +#include <boost/test/test_tools.hpp> +#else +#include "test.hpp" +#endif + +namespace boost{ + namespace detail{ + + /* + macro: + BOOST_CHECK_INTEGRAL_CONSTANT(expression, expected_value) + + expression: an integral constant expression to check. + expected_value: the value expected. + */ + + template <long test_value> + struct integral_constant + { + static long value() { return test_value; } + }; + + template <class T, class U> + bool tt_compare(T found, U expected) + { return static_cast<U>(found) == expected; } + +#define BOOST_CHECK_INTEGRAL_CONSTANT(expression, expected_value)\ + if(!::boost::detail::tt_compare(::boost::detail::integral_constant<(int)(expression)>::value(), (int)expression)){\ + BOOST_CHECK_MESSAGE(false, "The expression: \"" << BOOST_STRINGIZE(expression) << "\" had differing values depending upon whether it was used as an integral constant expression or not");\ + }else{\ + BOOST_CHECK_MESSAGE(true, "Validating Integral Constant Expression: \"" << BOOST_STRINGIZE(expression) << "\"");\ + }\ + if(!::boost::detail::tt_compare((int)expression, expected_value))\ + BOOST_CHECK_MESSAGE(false, "The expression: \"" << BOOST_STRINGIZE(expression) << "\" had an invalid value (found " << ::boost::detail::integral_constant<(int)(expression)>::value() << ", expected " << expected_value << ")" ) + + /* + macro: + BOOST_CHECK_SOFT_INTEGRAL_CONSTANT(expression, expected_value, alternate_value) + + expression: an integral constant expression to check. + expected_value: the value expected. + alternate_value: an alternative value that results is a warning not a failure if found. + */ + +#define BOOST_CHECK_SOFT_INTEGRAL_CONSTANT(expression, expected_value, alternate_value)\ + if(!::boost::detail::tt_compare(::boost::detail::integral_constant<(int)(expression)>::value(), (int)expression)){\ + BOOST_CHECK_MESSAGE(false, "The expression: \"" << BOOST_STRINGIZE(expression) << "\" had differing values depending upon whether it was used as an integral constant expression or not");\ + }else{\ + BOOST_CHECK_MESSAGE(true, "Validating Integral Constant Expression: \"" << BOOST_STRINGIZE(expression) << "\"");\ + }\ + if(!::boost::detail::tt_compare((int)expression, expected_value))\ + {\ + if(!::boost::detail::tt_compare((int)expression, alternate_value))\ + {\ + BOOST_CHECK_MESSAGE(false, "The expression: \"" << BOOST_STRINGIZE(expression) << "\" had an invalid value (found " << ::boost::detail::integral_constant<(int)(expression)>::value() << ", expected " << expected_value << ")" );\ + }\ + else\ + {\ + BOOST_WARN_MESSAGE(false, "<note>The expression: \"" << BOOST_STRINGIZE(expression) << "\" did not have the value we wish it to have (found " << ::boost::detail::integral_constant<(int)(expression)>::value() << ", expected " << expected_value << ")</note>" );\ + }\ + } + + + }//detail +}//boost + + +#endif + + + + + diff --git a/libs/type_traits/test/check_type.hpp b/libs/type_traits/test/check_type.hpp new file mode 100644 index 0000000000..33ed39940b --- /dev/null +++ b/libs/type_traits/test/check_type.hpp @@ -0,0 +1,71 @@ + +// (C) Copyright John Maddock 2000. +// 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) + +#ifndef BOOST_CHECK_TYPE_HPP +#define BOOST_CHECK_TYPE_HPP + +#ifdef USE_UNIT_TEST +#include <boost/test/test_tools.hpp> +#else +#include "test.hpp" +#endif +#include <boost/type_traits/is_same.hpp> + +/* +macro: +BOOST_CHECK_TYPE(type_expression, expected_type) + +type_expression: an expression that evaluates to a typename. +expected_value: the type we expect to find. +*/ + +#ifdef __BORLANDC__ +#pragma option -w-8008 -w-8066 -w-8019 +#endif + + +#define BOOST_CHECK_TYPE(type_expression, expected_type)\ +do{\ + if(!::boost::is_same< type_expression, expected_type >::value){\ + BOOST_CHECK_MESSAGE(false, "The expression: \"" << BOOST_STRINGIZE(expression)\ + << "\" did not have the expected type:\n\tevaluating: boost::is_same<"\ + << BOOST_STRINGIZE(type_expression) << ", " << BOOST_STRINGIZE(expected_type)\ + << ">" << "\n\tfound: "\ + << typeid(::boost::is_same< type_expression, expected_type >).name());\ + }else\ + BOOST_CHECK_MESSAGE(true, "Validating Type Expression: \""\ + << BOOST_STRINGIZE(expression) << "\"");\ +}while(0) + +#define BOOST_CHECK_TYPE3(type_expression, type_expression_suffix, expected_type)\ +do{\ + if(!::boost::is_same< type_expression, type_expression_suffix, expected_type >::value){\ + BOOST_CHECK_MESSAGE(false, "The expression: \"" << BOOST_STRINGIZE(expression)\ + << "\" did not have the expected type:\n\tevaluating: boost::is_same<"\ + << BOOST_STRINGIZE((type_expression, type_expression_suffix)) << ", " << BOOST_STRINGIZE(expected_type)\ + << ">" << "\n\tfound: "\ + << typeid(::boost::is_same< type_expression, type_expression_suffix, expected_type >).name());\ + }else\ + BOOST_CHECK_MESSAGE(true, "Validating Type Expression: \""\ + << BOOST_STRINGIZE(expression) << "\"");\ +}while(0) + +#define BOOST_CHECK_TYPE4(type_expression, suffix1, suffix2, expected_type)\ +do{\ + if(!::boost::is_same< type_expression, suffix1, suffix2, expected_type >::value){\ + BOOST_CHECK_MESSAGE(false, "The expression: \"" << BOOST_STRINGIZE(expression)\ + << "\" did not have the expected type:\n\tevaluating: boost::is_same<"\ + << BOOST_STRINGIZE((type_expression, suffix1, suffix2)) << ", " << BOOST_STRINGIZE(expected_type)\ + << ">" << "\n\tfound: "\ + << typeid(::boost::is_same< type_expression, suffix1, suffix2, expected_type >).name());\ + }else\ + BOOST_CHECK_MESSAGE(true, "Validating Type Expression: \""\ + << BOOST_STRINGIZE(expression) << "\"");\ +}while(0) + +#endif + + diff --git a/libs/type_traits/test/common_type_2_test.cpp b/libs/type_traits/test/common_type_2_test.cpp new file mode 100644 index 0000000000..c76c2efd45 --- /dev/null +++ b/libs/type_traits/test/common_type_2_test.cpp @@ -0,0 +1,217 @@ +// common_type_test.cpp ----------------------------------------------------// + +// Copyright 2010 Beman Dawes + +// Distributed under the Boost Software License, Version 1.0. +// See http://www.boost.org/LICENSE_1_0.txt + +#define BOOST_COMMON_TYPE_DONT_USE_TYPEOF 1 + +#include "test.hpp" +#include "check_type.hpp" +#ifdef TEST_STD +# include <type_traits> +#else +# include <boost/type_traits/common_type.hpp> +#endif +#include <iostream> + +#ifdef BOOST_INTEL +#pragma warning(disable: 304 383) +#endif + +struct C1 {}; + +struct C2 {}; + + +struct C3 : C2 {}; +struct C1C2 { + C1C2() {} + C1C2(C1 const&) {} + C1C2(C2 const&) {} + C1C2& operator=(C1C2 const&) { + return *this; + } +}; + +template <typename C, typename A> +void proc2(typename boost::common_type<A, C>::type const& ) {} + +template <typename C, typename A, typename B> +void proc3(typename boost::common_type<C, A, B>::type const& ) {} + +template <typename C, typename A> +void assignation_2() { +typedef typename boost::common_type<A, C>::type AC; + A a; + C c; + AC ac; + ac=a; + ac=c; + + proc2<C, A>(a); + proc2<C, A>(c); + +} + +template <typename C, typename A, typename B> +void assignation_3() { +typedef typename boost::common_type<C, A, B>::type ABC; + A a; + B b; + C c; + ABC abc; + + abc=a; + abc=b; + abc=c; + + proc3<C, A, B>(a); + proc3<C, A, B>(b); + proc3<C, A, B>(c); +} + +C1C2 c1c2; +C1 c1; + +int f(C1C2 ) { return 1;} +int f(C1 ) { return 2;} +template <typename OSTREAM> +OSTREAM& operator<<(OSTREAM& os, C1 const&) {return os;} + +C1C2& declval_C1C2() {return c1c2;} +C1& declval_C1(){return c1;} +bool declval_bool(){return true;} + + +TT_TEST_BEGIN(common_type) +{ +#ifndef __SUNPRO_CC + assignation_2<C1C2, C1>(); + typedef tt::common_type<C1C2&, C1&>::type T1; + typedef tt::common_type<C3*, C2*>::type T2; + typedef tt::common_type<int*, int const*>::type T3; +#if defined(BOOST_NO_DECLTYPE) && !defined(BOOST_COMMON_TYPE_DONT_USE_TYPEOF) + // fails if BOOST_COMMON_TYPE_DONT_USE_TYPEOF: + typedef tt::common_type<int volatile*, int const*>::type T4; +#endif + typedef tt::common_type<int*, int volatile*>::type T5; + + assignation_2<C1, C1C2>(); + assignation_2<C1C2, C2>(); + assignation_2<C2, C1C2>(); + assignation_3<C1, C1C2, C2>(); + assignation_3<C1C2, C1, C2>(); + assignation_3<C2, C1C2, C1>(); + assignation_3<C1C2, C2, C1>(); + //assignation_3<C1, C2, C1C2>(); // fails because the common type is the third +#endif + + typedef tt::common_type<C1C2, C1>::type t1; + BOOST_CHECK_TYPE(t1, C1C2); + + BOOST_CHECK_TYPE(tt::common_type<int>::type, int); + BOOST_CHECK_TYPE(tt::common_type<char>::type, char); + + BOOST_CHECK_TYPE3(tt::common_type<char, char>::type, char); + BOOST_CHECK_TYPE3(tt::common_type<char, unsigned char>::type, int); + BOOST_CHECK_TYPE3(tt::common_type<char, short>::type, int); + BOOST_CHECK_TYPE3(tt::common_type<char, unsigned short>::type, int); + BOOST_CHECK_TYPE3(tt::common_type<char, int>::type, int); + BOOST_CHECK_TYPE3(tt::common_type<char, unsigned int>::type, unsigned int); +#ifndef BOOST_NO_LONG_LONG + BOOST_CHECK_TYPE3(tt::common_type<char, boost::long_long_type>::type, boost::long_long_type); + BOOST_CHECK_TYPE3(tt::common_type<char, boost::ulong_long_type>::type, boost::ulong_long_type); +#endif + BOOST_CHECK_TYPE3(tt::common_type<char, double>::type, double); + + BOOST_CHECK_TYPE3(tt::common_type<unsigned char, char>::type, int); + BOOST_CHECK_TYPE3(tt::common_type<unsigned char, unsigned char>::type, unsigned char); + BOOST_CHECK_TYPE3(tt::common_type<unsigned char, short>::type, int); + BOOST_CHECK_TYPE3(tt::common_type<unsigned char, unsigned short>::type, int); + BOOST_CHECK_TYPE3(tt::common_type<unsigned char, int>::type, int); + BOOST_CHECK_TYPE3(tt::common_type<unsigned char, unsigned int>::type, unsigned int); +#ifndef BOOST_NO_LONG_LONG + BOOST_CHECK_TYPE3(tt::common_type<unsigned char, boost::long_long_type>::type, boost::long_long_type); + BOOST_CHECK_TYPE3(tt::common_type<unsigned char, boost::ulong_long_type>::type, boost::ulong_long_type); +#endif + BOOST_CHECK_TYPE3(tt::common_type<unsigned char, double>::type, double); + + BOOST_CHECK_TYPE3(tt::common_type<short, char>::type, int); + BOOST_CHECK_TYPE3(tt::common_type<short, unsigned char>::type, int); + BOOST_CHECK_TYPE3(tt::common_type<short, short>::type, short); + BOOST_CHECK_TYPE3(tt::common_type<short, unsigned short>::type, int); + BOOST_CHECK_TYPE3(tt::common_type<short, int>::type, int); + BOOST_CHECK_TYPE3(tt::common_type<short, unsigned int>::type, unsigned int); +#ifndef BOOST_NO_LONG_LONG + BOOST_CHECK_TYPE3(tt::common_type<short, boost::long_long_type>::type, boost::long_long_type); + BOOST_CHECK_TYPE3(tt::common_type<short, boost::ulong_long_type>::type, boost::ulong_long_type); +#endif + BOOST_CHECK_TYPE3(tt::common_type<short, double>::type, double); + + BOOST_CHECK_TYPE3(tt::common_type<unsigned short, char>::type, int); + BOOST_CHECK_TYPE3(tt::common_type<unsigned short, unsigned char>::type, int); + BOOST_CHECK_TYPE3(tt::common_type<unsigned short, short>::type, int); + BOOST_CHECK_TYPE3(tt::common_type<unsigned short, unsigned short>::type, unsigned short); + BOOST_CHECK_TYPE3(tt::common_type<unsigned short, int>::type, int); + BOOST_CHECK_TYPE3(tt::common_type<unsigned short, unsigned int>::type, unsigned int); +#ifndef BOOST_NO_LONG_LONG + BOOST_CHECK_TYPE3(tt::common_type<unsigned short, boost::long_long_type>::type, boost::long_long_type); + BOOST_CHECK_TYPE3(tt::common_type<unsigned short, boost::ulong_long_type>::type, boost::ulong_long_type); +#endif + BOOST_CHECK_TYPE3(tt::common_type<unsigned short, double>::type, double); + + BOOST_CHECK_TYPE3(tt::common_type<int, char>::type, int); + BOOST_CHECK_TYPE3(tt::common_type<int, unsigned char>::type, int); + BOOST_CHECK_TYPE3(tt::common_type<int, short>::type, int); + BOOST_CHECK_TYPE3(tt::common_type<int, unsigned short>::type, int); + BOOST_CHECK_TYPE3(tt::common_type<int, int>::type, int); + BOOST_CHECK_TYPE3(tt::common_type<int, unsigned int>::type, unsigned int); +#ifndef BOOST_NO_LONG_LONG + BOOST_CHECK_TYPE3(tt::common_type<int, boost::long_long_type>::type, boost::long_long_type); + BOOST_CHECK_TYPE3(tt::common_type<int, boost::ulong_long_type>::type, boost::ulong_long_type); +#endif + BOOST_CHECK_TYPE3(tt::common_type<int, double>::type, double); + + BOOST_CHECK_TYPE3(tt::common_type<unsigned int, char>::type, unsigned int); + BOOST_CHECK_TYPE3(tt::common_type<unsigned int, unsigned char>::type, unsigned int); + BOOST_CHECK_TYPE3(tt::common_type<unsigned int, short>::type, unsigned int); + BOOST_CHECK_TYPE3(tt::common_type<unsigned int, unsigned short>::type, unsigned int); + BOOST_CHECK_TYPE3(tt::common_type<unsigned int, int>::type, unsigned int); + BOOST_CHECK_TYPE3(tt::common_type<unsigned int, unsigned int>::type, unsigned int); +#ifndef BOOST_NO_LONG_LONG + BOOST_CHECK_TYPE3(tt::common_type<unsigned int, boost::long_long_type>::type, boost::long_long_type); + BOOST_CHECK_TYPE3(tt::common_type<unsigned int, boost::ulong_long_type>::type, boost::ulong_long_type); +#endif + BOOST_CHECK_TYPE3(tt::common_type<unsigned int, double>::type, double); + +#ifndef BOOST_NO_LONG_LONG + BOOST_CHECK_TYPE3(tt::common_type<boost::long_long_type, char>::type, boost::long_long_type); + BOOST_CHECK_TYPE3(tt::common_type<boost::long_long_type, unsigned char>::type, boost::long_long_type); + BOOST_CHECK_TYPE3(tt::common_type<boost::long_long_type, short>::type, boost::long_long_type); + BOOST_CHECK_TYPE3(tt::common_type<boost::long_long_type, unsigned short>::type, boost::long_long_type); + BOOST_CHECK_TYPE3(tt::common_type<boost::long_long_type, int>::type, boost::long_long_type); + BOOST_CHECK_TYPE3(tt::common_type<boost::long_long_type, unsigned int>::type, boost::long_long_type); + BOOST_CHECK_TYPE3(tt::common_type<boost::long_long_type, boost::long_long_type>::type, boost::long_long_type); + BOOST_CHECK_TYPE3(tt::common_type<boost::long_long_type, boost::ulong_long_type>::type, boost::ulong_long_type); + BOOST_CHECK_TYPE3(tt::common_type<boost::long_long_type, double>::type, double); +#endif + BOOST_CHECK_TYPE3(tt::common_type<double, char>::type, double); + BOOST_CHECK_TYPE3(tt::common_type<double, unsigned char>::type, double); + BOOST_CHECK_TYPE3(tt::common_type<double, short>::type, double); + BOOST_CHECK_TYPE3(tt::common_type<double, unsigned short>::type, double); + BOOST_CHECK_TYPE3(tt::common_type<double, int>::type, double); + BOOST_CHECK_TYPE3(tt::common_type<double, unsigned int>::type, double); +#ifndef BOOST_NO_LONG_LONG + BOOST_CHECK_TYPE3(tt::common_type<double, boost::long_long_type>::type, double); + BOOST_CHECK_TYPE3(tt::common_type<double, boost::ulong_long_type>::type, double); +#endif + BOOST_CHECK_TYPE3(tt::common_type<double, double>::type, double); + + BOOST_CHECK_TYPE4(tt::common_type<double, char, int>::type, double); +#ifndef BOOST_NO_LONG_LONG + BOOST_CHECK_TYPE4(tt::common_type<unsigned, char, boost::long_long_type>::type, boost::long_long_type); +#endif +} +TT_TEST_END diff --git a/libs/type_traits/test/common_type_fail.cpp b/libs/type_traits/test/common_type_fail.cpp new file mode 100644 index 0000000000..2b522526b2 --- /dev/null +++ b/libs/type_traits/test/common_type_fail.cpp @@ -0,0 +1,27 @@ +// common_type_test.cpp ----------------------------------------------------// + +// Copyright 2010 Beman Dawes + +// Distributed under the Boost Software License, Version 1.0. +// See http://www.boost.org/LICENSE_1_0.txt + +#define _CRT_SECURE_NO_WARNINGS // disable VC++ foolishness + +#include "test.hpp" +#ifndef TEST_STD +#include <boost/type_traits/common_type.hpp> +#else +#include <type_traits> +#endif + +struct C1 { + //~ private: + //~ C1(); +}; + +struct C2 {}; + + + +typedef tt::common_type<C1, C2>::type AC; + diff --git a/libs/type_traits/test/common_type_test.cpp b/libs/type_traits/test/common_type_test.cpp new file mode 100644 index 0000000000..bd1a54aca7 --- /dev/null +++ b/libs/type_traits/test/common_type_test.cpp @@ -0,0 +1,210 @@ +// common_type_test.cpp ----------------------------------------------------// + +// Copyright 2010 Beman Dawes + +// Distributed under the Boost Software License, Version 1.0. +// See http://www.boost.org/LICENSE_1_0.txt + +#include "test.hpp" +#include "check_type.hpp" +#ifdef TEST_STD +# include <type_traits> +#else +# include <boost/type_traits/common_type.hpp> +#endif +#include <iostream> + +#ifdef BOOST_INTEL +#pragma warning(disable: 304 383) +#endif + +struct C1 {}; + +struct C2 {}; + + +struct C3 : C2 {}; +struct C1C2 { + C1C2() {} + C1C2(C1 const&) {} + C1C2(C2 const&) {} + C1C2& operator=(C1C2 const&) { + return *this; + } +}; + +template <typename C, typename A> +void proc2(typename boost::common_type<A, C>::type const& ) {} + +template <typename C, typename A, typename B> +void proc3(typename boost::common_type<C, A, B>::type const& ) {} + +template <typename C, typename A> +void assignation_2() { +typedef typename boost::common_type<A, C>::type AC; + A a; + C c; + AC ac; + ac=a; + ac=c; + + proc2<C, A>(a); + proc2<C, A>(c); + +} + +template <typename C, typename A, typename B> +void assignation_3() { +typedef typename boost::common_type<C, A, B>::type ABC; + A a; + B b; + C c; + ABC abc; + + abc=a; + abc=b; + abc=c; + + proc3<C, A, B>(a); + proc3<C, A, B>(b); + proc3<C, A, B>(c); +} + +C1C2 c1c2; +C1 c1; + +int f(C1C2 ) { return 1;} +int f(C1 ) { return 2;} +template <typename OSTREAM> +OSTREAM& operator<<(OSTREAM& os, C1 const&) {return os;} + +C1C2& declval_C1C2() {return c1c2;} +C1& declval_C1(){return c1;} +bool declval_bool(){return true;} + + +TT_TEST_BEGIN(common_type) +{ + assignation_2<C1C2, C1>(); + typedef tt::common_type<C1C2&, C1&>::type T1; + typedef tt::common_type<C3*, C2*>::type T2; + typedef tt::common_type<int*, int const*>::type T3; +#if defined(BOOST_NO_DECLTYPE) && !defined(BOOST_COMMON_TYPE_DONT_USE_TYPEOF) + // fails if BOOST_COMMON_TYPE_DONT_USE_TYPEOF: + typedef tt::common_type<int volatile*, int const*>::type T4; +#endif + typedef tt::common_type<int*, int volatile*>::type T5; + + assignation_2<C1, C1C2>(); + assignation_2<C1C2, C2>(); + assignation_2<C2, C1C2>(); + assignation_3<C1, C1C2, C2>(); + assignation_3<C1C2, C1, C2>(); + assignation_3<C2, C1C2, C1>(); + assignation_3<C1C2, C2, C1>(); + //assignation_3<C1, C2, C1C2>(); // fails because the common type is the third + + BOOST_CHECK_TYPE(tt::common_type<int>::type, int); + BOOST_CHECK_TYPE(tt::common_type<char>::type, char); + + BOOST_CHECK_TYPE3(tt::common_type<char, char>::type, char); + BOOST_CHECK_TYPE3(tt::common_type<char, unsigned char>::type, int); + BOOST_CHECK_TYPE3(tt::common_type<char, short>::type, int); + BOOST_CHECK_TYPE3(tt::common_type<char, unsigned short>::type, int); + BOOST_CHECK_TYPE3(tt::common_type<char, int>::type, int); + BOOST_CHECK_TYPE3(tt::common_type<char, unsigned int>::type, unsigned int); +#ifndef BOOST_NO_LONG_LONG + BOOST_CHECK_TYPE3(tt::common_type<char, boost::long_long_type>::type, boost::long_long_type); + BOOST_CHECK_TYPE3(tt::common_type<char, boost::ulong_long_type>::type, boost::ulong_long_type); +#endif + BOOST_CHECK_TYPE3(tt::common_type<char, double>::type, double); + + BOOST_CHECK_TYPE3(tt::common_type<unsigned char, char>::type, int); + BOOST_CHECK_TYPE3(tt::common_type<unsigned char, unsigned char>::type, unsigned char); + BOOST_CHECK_TYPE3(tt::common_type<unsigned char, short>::type, int); + BOOST_CHECK_TYPE3(tt::common_type<unsigned char, unsigned short>::type, int); + BOOST_CHECK_TYPE3(tt::common_type<unsigned char, int>::type, int); + BOOST_CHECK_TYPE3(tt::common_type<unsigned char, unsigned int>::type, unsigned int); +#ifndef BOOST_NO_LONG_LONG + BOOST_CHECK_TYPE3(tt::common_type<unsigned char, boost::long_long_type>::type, boost::long_long_type); + BOOST_CHECK_TYPE3(tt::common_type<unsigned char, boost::ulong_long_type>::type, boost::ulong_long_type); +#endif + BOOST_CHECK_TYPE3(tt::common_type<unsigned char, double>::type, double); + + BOOST_CHECK_TYPE3(tt::common_type<short, char>::type, int); + BOOST_CHECK_TYPE3(tt::common_type<short, unsigned char>::type, int); + BOOST_CHECK_TYPE3(tt::common_type<short, short>::type, short); + BOOST_CHECK_TYPE3(tt::common_type<short, unsigned short>::type, int); + BOOST_CHECK_TYPE3(tt::common_type<short, int>::type, int); + BOOST_CHECK_TYPE3(tt::common_type<short, unsigned int>::type, unsigned int); +#ifndef BOOST_NO_LONG_LONG + BOOST_CHECK_TYPE3(tt::common_type<short, boost::long_long_type>::type, boost::long_long_type); + BOOST_CHECK_TYPE3(tt::common_type<short, boost::ulong_long_type>::type, boost::ulong_long_type); +#endif + BOOST_CHECK_TYPE3(tt::common_type<short, double>::type, double); + + BOOST_CHECK_TYPE3(tt::common_type<unsigned short, char>::type, int); + BOOST_CHECK_TYPE3(tt::common_type<unsigned short, unsigned char>::type, int); + BOOST_CHECK_TYPE3(tt::common_type<unsigned short, short>::type, int); + BOOST_CHECK_TYPE3(tt::common_type<unsigned short, unsigned short>::type, unsigned short); + BOOST_CHECK_TYPE3(tt::common_type<unsigned short, int>::type, int); + BOOST_CHECK_TYPE3(tt::common_type<unsigned short, unsigned int>::type, unsigned int); +#ifndef BOOST_NO_LONG_LONG + BOOST_CHECK_TYPE3(tt::common_type<unsigned short, boost::long_long_type>::type, boost::long_long_type); + BOOST_CHECK_TYPE3(tt::common_type<unsigned short, boost::ulong_long_type>::type, boost::ulong_long_type); +#endif + BOOST_CHECK_TYPE3(tt::common_type<unsigned short, double>::type, double); + + BOOST_CHECK_TYPE3(tt::common_type<int, char>::type, int); + BOOST_CHECK_TYPE3(tt::common_type<int, unsigned char>::type, int); + BOOST_CHECK_TYPE3(tt::common_type<int, short>::type, int); + BOOST_CHECK_TYPE3(tt::common_type<int, unsigned short>::type, int); + BOOST_CHECK_TYPE3(tt::common_type<int, int>::type, int); + BOOST_CHECK_TYPE3(tt::common_type<int, unsigned int>::type, unsigned int); +#ifndef BOOST_NO_LONG_LONG + BOOST_CHECK_TYPE3(tt::common_type<int, boost::long_long_type>::type, boost::long_long_type); + BOOST_CHECK_TYPE3(tt::common_type<int, boost::ulong_long_type>::type, boost::ulong_long_type); +#endif + BOOST_CHECK_TYPE3(tt::common_type<int, double>::type, double); + + BOOST_CHECK_TYPE3(tt::common_type<unsigned int, char>::type, unsigned int); + BOOST_CHECK_TYPE3(tt::common_type<unsigned int, unsigned char>::type, unsigned int); + BOOST_CHECK_TYPE3(tt::common_type<unsigned int, short>::type, unsigned int); + BOOST_CHECK_TYPE3(tt::common_type<unsigned int, unsigned short>::type, unsigned int); + BOOST_CHECK_TYPE3(tt::common_type<unsigned int, int>::type, unsigned int); + BOOST_CHECK_TYPE3(tt::common_type<unsigned int, unsigned int>::type, unsigned int); +#ifndef BOOST_NO_LONG_LONG + BOOST_CHECK_TYPE3(tt::common_type<unsigned int, boost::long_long_type>::type, boost::long_long_type); + BOOST_CHECK_TYPE3(tt::common_type<unsigned int, boost::ulong_long_type>::type, boost::ulong_long_type); +#endif + BOOST_CHECK_TYPE3(tt::common_type<unsigned int, double>::type, double); + +#ifndef BOOST_NO_LONG_LONG + BOOST_CHECK_TYPE3(tt::common_type<boost::long_long_type, char>::type, boost::long_long_type); + BOOST_CHECK_TYPE3(tt::common_type<boost::long_long_type, unsigned char>::type, boost::long_long_type); + BOOST_CHECK_TYPE3(tt::common_type<boost::long_long_type, short>::type, boost::long_long_type); + BOOST_CHECK_TYPE3(tt::common_type<boost::long_long_type, unsigned short>::type, boost::long_long_type); + BOOST_CHECK_TYPE3(tt::common_type<boost::long_long_type, int>::type, boost::long_long_type); + BOOST_CHECK_TYPE3(tt::common_type<boost::long_long_type, unsigned int>::type, boost::long_long_type); + BOOST_CHECK_TYPE3(tt::common_type<boost::long_long_type, boost::long_long_type>::type, boost::long_long_type); + BOOST_CHECK_TYPE3(tt::common_type<boost::long_long_type, boost::ulong_long_type>::type, boost::ulong_long_type); + BOOST_CHECK_TYPE3(tt::common_type<boost::long_long_type, double>::type, double); +#endif + BOOST_CHECK_TYPE3(tt::common_type<double, char>::type, double); + BOOST_CHECK_TYPE3(tt::common_type<double, unsigned char>::type, double); + BOOST_CHECK_TYPE3(tt::common_type<double, short>::type, double); + BOOST_CHECK_TYPE3(tt::common_type<double, unsigned short>::type, double); + BOOST_CHECK_TYPE3(tt::common_type<double, int>::type, double); + BOOST_CHECK_TYPE3(tt::common_type<double, unsigned int>::type, double); +#ifndef BOOST_NO_LONG_LONG + BOOST_CHECK_TYPE3(tt::common_type<double, boost::long_long_type>::type, double); + BOOST_CHECK_TYPE3(tt::common_type<double, boost::ulong_long_type>::type, double); +#endif + BOOST_CHECK_TYPE3(tt::common_type<double, double>::type, double); + + BOOST_CHECK_TYPE4(tt::common_type<double, char, int>::type, double); +#ifndef BOOST_NO_LONG_LONG + BOOST_CHECK_TYPE4(tt::common_type<unsigned, char, boost::long_long_type>::type, boost::long_long_type); +#endif +} +TT_TEST_END diff --git a/libs/type_traits/test/conditional_test.cpp b/libs/type_traits/test/conditional_test.cpp new file mode 100644 index 0000000000..1cc35342df --- /dev/null +++ b/libs/type_traits/test/conditional_test.cpp @@ -0,0 +1,31 @@ + +// (C) Copyright John Maddock 2010. +// 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/conditional.hpp> +#endif +#include <boost/type_traits/is_same.hpp> + +TT_TEST_BEGIN(conditional) + +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_same< ::tt::conditional<true, int, long>::type, int>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_same< ::tt::conditional<false, int, long>::type, long>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_same< ::tt::conditional<true, int, long>::type, long>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_same< ::tt::conditional<false, int, long>::type, int>::value), false); + +TT_TEST_END + + + + + + + + diff --git a/libs/type_traits/test/decay_test.cpp b/libs/type_traits/test/decay_test.cpp new file mode 100644 index 0000000000..f1ad1e4efd --- /dev/null +++ b/libs/type_traits/test/decay_test.cpp @@ -0,0 +1,127 @@ + +// (C) Copyright John Maddock & Thorsten Ottosen 2005. +// 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/decay.hpp> +# include <boost/type_traits/is_same.hpp> +#endif +#include <iostream> +#include <string> +#include <utility> + +#ifdef BOOST_INTEL +// remark #383: value copied to temporary, reference to temporary used +// std::pair<std::string, int> p2 = boost::make_pair( "foo", 1 ); +// ^ +#pragma warning(disable:383) +#endif + +namespace boost +{ + + int proc1() + { + return 0; + } + int proc2(int c) + { + return c; + } + + // + // An almost optimal version of std::make_pair() + // + template< class F, class S > + inline std::pair< BOOST_DEDUCED_TYPENAME tt::decay<const F>::type, + BOOST_DEDUCED_TYPENAME tt::decay<const S>::type > + make_pair( const F& f, const S& s ) + { + return std::pair< BOOST_DEDUCED_TYPENAME tt::decay<const F>::type, + BOOST_DEDUCED_TYPENAME tt::decay<const S>::type >( f, s ); + } + + /* + This overload will mess up vc7.1 + + template< class F, class S > + inline std::pair< BOOST_DEDUCED_TYPENAME ::tt::decay<F>::type, + BOOST_DEDUCED_TYPENAME ::tt::decay<S>::type > + make_pair( F& f, S& s ) + { + return std::pair< BOOST_DEDUCED_TYPENAME ::tt::decay<F>::type, + BOOST_DEDUCED_TYPENAME ::tt::decay<S>::type >( f, s ); + } + */ +} + +TT_TEST_BEGIN(is_class) + + BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_same< + ::tt::decay<int>::type,int>::value), + true ); + BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_same< + ::tt::decay<char[2]>::type,char*>::value), + true ); + BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_same< + ::tt::decay<char[2][3]>::type,char(*)[3]>::value), + true ); + BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_same< + ::tt::decay<const char[2]>::type,const char*>::value), + true ); + BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_same< + ::tt::decay<wchar_t[2]>::type,wchar_t*>::value), + true ); + BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_same< + ::tt::decay<const wchar_t[2]>::type,const wchar_t*>::value), + true ); + BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_same< + ::tt::decay<const wchar_t[2]>::type,const wchar_t*>::value), + true ); + + typedef int f1_type(void); + typedef int f2_type(int); + + BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_same< + ::tt::decay<f1_type>::type,int (*)(void)>::value), + true ); + BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_same< + ::tt::decay<f2_type>::type,int (*)(int)>::value), + true ); + + std::pair<std::string,std::string> p = boost::make_pair( "foo", "bar" ); + std::pair<std::string, int> p2 = boost::make_pair( "foo", 1 ); +#ifndef BOOST_NO_STD_WSTRING + std::pair<std::wstring,std::string> p3 = boost::make_pair( L"foo", "bar" ); + std::pair<std::wstring, int> p4 = boost::make_pair( L"foo", 1 ); +#endif + + // + // Todo: make these work sometime. The test id not directly + // related to decay<T>::type and can be avioded for now. + // + /* + int array[10]; + std::pair<int*,int*> p5 = boost::make_pair( array, array ); +#ifndef __BORLANDC__ + std::pair<int(*)(void), int(*)(int)> p6 = boost::make_pair(boost::proc1, boost::proc2); + p6.first(); + p6.second(1); +#endif + */ + +TT_TEST_END + + + + + + + + diff --git a/libs/type_traits/test/extent_test.cpp b/libs/type_traits/test/extent_test.cpp new file mode 100644 index 0000000000..6e5b699960 --- /dev/null +++ b/libs/type_traits/test/extent_test.cpp @@ -0,0 +1,49 @@ + +// (C) Copyright John Maddock 2005. +// 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/extent.hpp> +#endif + +TT_TEST_BEGIN(extent) + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::extent<int>::value, 0); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::extent<int[]>::value, 0); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::extent<int[][10]>::value, 0); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::extent<int[5][10]>::value, 5); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::extent<int[5][10][40]>::value, 5); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::extent<int (&)[5][10]>::value, 0); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::extent<int (*)[5][10]>::value, 0); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::extent<int,1>::value), 0); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::extent<int[],1>::value), 0); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::extent<int[][10],1>::value), 10); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::extent<int[5][10],1>::value), 10); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::extent<int[5][10][40],1>::value), 10); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::extent<int (&)[5][10],1>::value), 0); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::extent<int (*)[5][10],1>::value), 0); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::extent<int[5][10],2>::value), 0); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::extent<int[5][10][40],2>::value), 40); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::extent<int[5][10][40],3>::value), 0); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::extent<int*>::value, 0); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::extent<int&>::value, 0); +#ifndef BOOST_NO_RVALUE_REFERENCES +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::extent<int&&>::value, 0); +#endif + +TT_TEST_END + + + + + + + + diff --git a/libs/type_traits/test/function_traits_test.cpp b/libs/type_traits/test/function_traits_test.cpp new file mode 100644 index 0000000000..f08e8101f5 --- /dev/null +++ b/libs/type_traits/test/function_traits_test.cpp @@ -0,0 +1,68 @@ + +// (C) Copyright John Maddock 2000. +// 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_type.hpp" +#include "check_integral_constant.hpp" +#ifdef TEST_STD +# include <type_traits> +#else +# include <boost/type_traits/function_traits.hpp> +#endif + +typedef void(pf_zero1)(); +typedef int(pf_zero2)(); +typedef const int& (pf_zero3)(); +typedef void(pf_one1)(int); +typedef int(pf_one2)(int); +typedef const int&(pf_one3)(const int&); +typedef void(pf_two1)(int,int); +typedef int(pf_two2)(int,int); +typedef const int&(pf_two3)(const int&,const int&); + + +TT_TEST_BEGIN(function_traits) + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::function_traits<pf_zero1>::arity, 0); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::function_traits<pf_zero2>::arity, 0); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::function_traits<pf_zero3>::arity, 0); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::function_traits<pf_one1>::arity, 1); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::function_traits<pf_one2>::arity, 1); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::function_traits<pf_one3>::arity, 1); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::function_traits<pf_two1>::arity, 2); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::function_traits<pf_two2>::arity, 2); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::function_traits<pf_two3>::arity, 2); + +BOOST_CHECK_TYPE(void, ::tt::function_traits<pf_zero1>::result_type); +BOOST_CHECK_TYPE(::tt::function_traits<pf_zero2>::result_type, int); +BOOST_CHECK_TYPE(::tt::function_traits<pf_zero3>::result_type, const int&); +BOOST_CHECK_TYPE(::tt::function_traits<pf_one1>::result_type, void); +BOOST_CHECK_TYPE(::tt::function_traits<pf_one2>::result_type, int); +BOOST_CHECK_TYPE(::tt::function_traits<pf_one3>::result_type, const int&); +BOOST_CHECK_TYPE(::tt::function_traits<pf_two1>::result_type, void); +BOOST_CHECK_TYPE(::tt::function_traits<pf_two2>::result_type, int); +BOOST_CHECK_TYPE(::tt::function_traits<pf_two3>::result_type, const int&); + +BOOST_CHECK_TYPE(::tt::function_traits<pf_one1>::arg1_type, int); +BOOST_CHECK_TYPE(::tt::function_traits<pf_one2>::arg1_type, int); +BOOST_CHECK_TYPE(::tt::function_traits<pf_one3>::arg1_type, const int&); + +BOOST_CHECK_TYPE(::tt::function_traits<pf_two1>::arg1_type, int); +BOOST_CHECK_TYPE(::tt::function_traits<pf_two2>::arg1_type, int); +BOOST_CHECK_TYPE(::tt::function_traits<pf_two3>::arg1_type, const int&); +BOOST_CHECK_TYPE(::tt::function_traits<pf_two1>::arg2_type, int); +BOOST_CHECK_TYPE(::tt::function_traits<pf_two2>::arg2_type, int); +BOOST_CHECK_TYPE(::tt::function_traits<pf_two3>::arg2_type, const int&); + +TT_TEST_END + + + + + + + + diff --git a/libs/type_traits/test/has_binary_classes.hpp b/libs/type_traits/test/has_binary_classes.hpp new file mode 100644 index 0000000000..1ecf60de55 --- /dev/null +++ b/libs/type_traits/test/has_binary_classes.hpp @@ -0,0 +1,252 @@ +// (C) Copyright Frederic Bron 2009-2011. +// 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) + +#ifndef TT_HAS_BINARY_CLASSES_HPP +#define TT_HAS_BINARY_CLASSES_HPP + +struct ret { }; +ret ret_val; + +class C000 { C000(); public: C000(int) { } }; +void operator+(C000, C000) { } + +class C001 { C001(); public: C001(int) { } }; +ret operator+(C001, C001) { return ret_val; } + +class C002 { C002(); public: C002(int) { } }; +ret const operator+(C002, C002) { return ret_val; } + +class C005 { C005(); public: C005(int) { } }; +ret & operator+(C005, C005) { return ret_val; } + +class C006 { C006(); public: C006(int) { } }; +ret const & operator+(C006, C006) { return ret_val; } + +class C009 { C009(); public: C009(int) { } }; +void operator+(C009, C009 const) { } + +class C010 { C010(); public: C010(int) { } }; +ret operator+(C010, C010 const) { return ret_val; } + +class C011 { C011(); public: C011(int) { } }; +ret const operator+(C011, C011 const) { return ret_val; } + +class C014 { C014(); public: C014(int) { } }; +ret & operator+(C014, C014 const) { return ret_val; } + +class C015 { C015(); public: C015(int) { } }; +ret const & operator+(C015, C015 const) { return ret_val; } + +class C036 { C036(); public: C036(int) { } }; +void operator+(C036, C036 &) { } + +class C037 { C037(); public: C037(int) { } }; +ret operator+(C037, C037 &) { return ret_val; } + +class C038 { C038(); public: C038(int) { } }; +ret const operator+(C038, C038 &) { return ret_val; } + +class C041 { C041(); public: C041(int) { } }; +ret & operator+(C041, C041 &) { return ret_val; } + +class C042 { C042(); public: C042(int) { } }; +ret const & operator+(C042, C042 &) { return ret_val; } + +class C045 { C045(); public: C045(int) { } }; +void operator+(C045, C045 const &) { } + +class C046 { C046(); public: C046(int) { } }; +ret operator+(C046, C046 const &) { return ret_val; } + +class C047 { C047(); public: C047(int) { } }; +ret const operator+(C047, C047 const &) { return ret_val; } + +class C050 { C050(); public: C050(int) { } }; +ret & operator+(C050, C050 const &) { return ret_val; } + +class C051 { C051(); public: C051(int) { } }; +ret const & operator+(C051, C051 const &) { return ret_val; } + +class C072 { C072(); public: C072(int) { } }; +void operator+(C072 const, C072) { } + +class C073 { C073(); public: C073(int) { } }; +ret operator+(C073 const, C073) { return ret_val; } + +class C074 { C074(); public: C074(int) { } }; +ret const operator+(C074 const, C074) { return ret_val; } + +class C077 { C077(); public: C077(int) { } }; +ret & operator+(C077 const, C077) { return ret_val; } + +class C078 { C078(); public: C078(int) { } }; +ret const & operator+(C078 const, C078) { return ret_val; } + +class C081 { C081(); public: C081(int) { } }; +void operator+(C081 const, C081 const) { } + +class C082 { C082(); public: C082(int) { } }; +ret operator+(C082 const, C082 const) { return ret_val; } + +class C083 { C083(); public: C083(int) { } }; +ret const operator+(C083 const, C083 const) { return ret_val; } + +class C086 { C086(); public: C086(int) { } }; +ret & operator+(C086 const, C086 const) { return ret_val; } + +class C087 { C087(); public: C087(int) { } }; +ret const & operator+(C087 const, C087 const) { return ret_val; } + +class C108 { C108(); public: C108(int) { } }; +void operator+(C108 const, C108 &) { } + +class C109 { C109(); public: C109(int) { } }; +ret operator+(C109 const, C109 &) { return ret_val; } + +class C110 { C110(); public: C110(int) { } }; +ret const operator+(C110 const, C110 &) { return ret_val; } + +class C113 { C113(); public: C113(int) { } }; +ret & operator+(C113 const, C113 &) { return ret_val; } + +class C114 { C114(); public: C114(int) { } }; +ret const & operator+(C114 const, C114 &) { return ret_val; } + +class C117 { C117(); public: C117(int) { } }; +void operator+(C117 const, C117 const &) { } + +class C118 { C118(); public: C118(int) { } }; +ret operator+(C118 const, C118 const &) { return ret_val; } + +class C119 { C119(); public: C119(int) { } }; +ret const operator+(C119 const, C119 const &) { return ret_val; } + +class C122 { C122(); public: C122(int) { } }; +ret & operator+(C122 const, C122 const &) { return ret_val; } + +class C123 { C123(); public: C123(int) { } }; +ret const & operator+(C123 const, C123 const &) { return ret_val; } + +class C288 { C288(); public: C288(int) { } }; +void operator+(C288 &, C288) { } + +class C289 { C289(); public: C289(int) { } }; +ret operator+(C289 &, C289) { return ret_val; } + +class C290 { C290(); public: C290(int) { } }; +ret const operator+(C290 &, C290) { return ret_val; } + +class C293 { C293(); public: C293(int) { } }; +ret & operator+(C293 &, C293) { return ret_val; } + +class C294 { C294(); public: C294(int) { } }; +ret const & operator+(C294 &, C294) { return ret_val; } + +class C297 { C297(); public: C297(int) { } }; +void operator+(C297 &, C297 const) { } + +class C298 { C298(); public: C298(int) { } }; +ret operator+(C298 &, C298 const) { return ret_val; } + +class C299 { C299(); public: C299(int) { } }; +ret const operator+(C299 &, C299 const) { return ret_val; } + +class C302 { C302(); public: C302(int) { } }; +ret & operator+(C302 &, C302 const) { return ret_val; } + +class C303 { C303(); public: C303(int) { } }; +ret const & operator+(C303 &, C303 const) { return ret_val; } + +class C324 { C324(); public: C324(int) { } }; +void operator+(C324 &, C324 &) { } + +class C325 { C325(); public: C325(int) { } }; +ret operator+(C325 &, C325 &) { return ret_val; } + +class C326 { C326(); public: C326(int) { } }; +ret const operator+(C326 &, C326 &) { return ret_val; } + +class C329 { C329(); public: C329(int) { } }; +ret & operator+(C329 &, C329 &) { return ret_val; } + +class C330 { C330(); public: C330(int) { } }; +ret const & operator+(C330 &, C330 &) { return ret_val; } + +class C333 { C333(); public: C333(int) { } }; +void operator+(C333 &, C333 const &) { } + +class C334 { C334(); public: C334(int) { } }; +ret operator+(C334 &, C334 const &) { return ret_val; } + +class C335 { C335(); public: C335(int) { } }; +ret const operator+(C335 &, C335 const &) { return ret_val; } + +class C338 { C338(); public: C338(int) { } }; +ret & operator+(C338 &, C338 const &) { return ret_val; } + +class C339 { C339(); public: C339(int) { } }; +ret const & operator+(C339 &, C339 const &) { return ret_val; } + +class C360 { C360(); public: C360(int) { } }; +void operator+(C360 const &, C360) { } + +class C361 { C361(); public: C361(int) { } }; +ret operator+(C361 const &, C361) { return ret_val; } + +class C362 { C362(); public: C362(int) { } }; +ret const operator+(C362 const &, C362) { return ret_val; } + +class C365 { C365(); public: C365(int) { } }; +ret & operator+(C365 const &, C365) { return ret_val; } + +class C366 { C366(); public: C366(int) { } }; +ret const & operator+(C366 const &, C366) { return ret_val; } + +class C369 { C369(); public: C369(int) { } }; +void operator+(C369 const &, C369 const) { } + +class C370 { C370(); public: C370(int) { } }; +ret operator+(C370 const &, C370 const) { return ret_val; } + +class C371 { C371(); public: C371(int) { } }; +ret const operator+(C371 const &, C371 const) { return ret_val; } + +class C374 { C374(); public: C374(int) { } }; +ret & operator+(C374 const &, C374 const) { return ret_val; } + +class C375 { C375(); public: C375(int) { } }; +ret const & operator+(C375 const &, C375 const) { return ret_val; } + +class C396 { C396(); public: C396(int) { } }; +void operator+(C396 const &, C396 &) { } + +class C397 { C397(); public: C397(int) { } }; +ret operator+(C397 const &, C397 &) { return ret_val; } + +class C398 { C398(); public: C398(int) { } }; +ret const operator+(C398 const &, C398 &) { return ret_val; } + +class C401 { C401(); public: C401(int) { } }; +ret & operator+(C401 const &, C401 &) { return ret_val; } + +class C402 { C402(); public: C402(int) { } }; +ret const & operator+(C402 const &, C402 &) { return ret_val; } + +class C405 { C405(); public: C405(int) { } }; +void operator+(C405 const &, C405 const &) { } + +class C406 { C406(); public: C406(int) { } }; +ret operator+(C406 const &, C406 const &) { return ret_val; } + +class C407 { C407(); public: C407(int) { } }; +ret const operator+(C407 const &, C407 const &) { return ret_val; } + +class C410 { C410(); public: C410(int) { } }; +ret & operator+(C410 const &, C410 const &) { return ret_val; } + +class C411 { C411(); public: C411(int) { } }; +ret const & operator+(C411 const &, C411 const &) { return ret_val; } + +#endif diff --git a/libs/type_traits/test/has_binary_classes0_test.cpp b/libs/type_traits/test/has_binary_classes0_test.cpp new file mode 100644 index 0000000000..a0aa635f66 --- /dev/null +++ b/libs/type_traits/test/has_binary_classes0_test.cpp @@ -0,0 +1,263 @@ +// (C) Copyright 2009-2011 Frederic Bron. +// 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" + +#include <boost/type_traits/has_operator.hpp> +#include "has_binary_classes.hpp" + +TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME) + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C000, C000, void >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C000, C000 const, void >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C000, C000 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C000, C000 const, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C000, C000 const &, void >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C000 const, C000, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C000 const, C000 const, void >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C000 const, C000 const, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C000 const, C000 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C000 const, C000 &, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C000 &, C000, void >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C000 &, C000, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C000 &, C000, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C000 &, C000 const, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C000 &, C000 const &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C000 &, C000 const &, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C000 const &, C000, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C000 const &, C000 const, void >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C000 const &, C000 const, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C000 const &, C000 &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C000 const &, C000 &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C001, C001, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C001, C001 const, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C001, C001 const, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C001, C001 &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C001 const, C001 &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C001 const, C001 &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C001 const, C001 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C001 const, C001 const &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C001 const, C001 const &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C001 &, C001, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C001 &, C001, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C001 &, C001, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C001 &, C001, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C001 &, C001 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C001 &, C001 &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C001 &, C001 &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C001 &, C001 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C001 const &, C001, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C001 const &, C001 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C001 const &, C001 const, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C001 const &, C001 const, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C001 const &, C001 &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C001 const &, C001 &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C001 const &, C001 &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C001 const &, C001 &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C001 const &, C001 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C001 const &, C001 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C001 const &, C001 const &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C002, C002, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C002, C002 const, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C002, C002 const, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C002, C002 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C002, C002 &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C002, C002 &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C002, C002 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C002, C002 const &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C002, C002 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C002 const, C002, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C002 const, C002 &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C002 const, C002 &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C002 const, C002 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C002 const, C002 const &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C002 const, C002 const &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C002 &, C002, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C002 &, C002, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C002 &, C002, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C002 &, C002, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C002 &, C002 const, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C002 &, C002 &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C002 &, C002 &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C002 &, C002 const &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C002 &, C002 const &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C002 &, C002 const &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C002 const &, C002, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C002 const &, C002, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C002 const &, C002, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C002 const &, C002 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C002 const &, C002 const, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C002 const &, C002 const, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C002 const &, C002 const, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C002 const &, C002 &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C002 const &, C002 &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C002 const &, C002 const &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C005, C005, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C005, C005, ret & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C005, C005, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C005, C005 const, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C005, C005 const, ret & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C005, C005 &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C005, C005 &, ret & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C005, C005 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C005, C005 const &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C005, C005 const &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C005, C005 const &, ret & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C005 const, C005, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C005 const, C005, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C005 const, C005 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C005 const, C005 &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C005 const, C005 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C005 const, C005 const &, ret & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C005 &, C005, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C005 &, C005, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C005 &, C005, ret & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C005 &, C005, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C005 &, C005 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C005 &, C005 const, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C005 &, C005 &, ret & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C005 &, C005 &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C005 const &, C005 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C005 const &, C005 const, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C005 const &, C005 const, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C005 const &, C005 const, ret & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C005 const &, C005 const, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C005 const &, C005 &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C005 const &, C005 &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C005 const &, C005 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C005 const &, C005 const &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C005 const &, C005 const &, ret & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C006, C006, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C006, C006 const, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C006, C006 &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C006 const, C006, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C006 const, C006, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C006 const, C006, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C006 const, C006 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C006 const, C006 &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C006 const, C006 &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C006 const, C006 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C006 const, C006 const &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C006 const, C006 const &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C006 &, C006, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C006 &, C006, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C006 &, C006, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C006 &, C006 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C006 &, C006 const, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C006 &, C006 &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C006 &, C006 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C006 const &, C006, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C006 const &, C006 const, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C006 const &, C006 &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C006 const &, C006 &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C006 const &, C006 const &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C006 const &, C006 const &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C009, C009, void >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C009, C009, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C009, C009 const, void >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C009, C009 const, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C009, C009 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C009, C009 &, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C009, C009 const &, void >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C009 const, C009, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C009 const, C009 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C009 const, C009 &, void >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C009 const, C009 &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C009 const, C009 &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C009 const, C009 const &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C009 const, C009 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C009 &, C009, void >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C009 &, C009, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C009 &, C009, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C009 &, C009 const, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C009 &, C009 &, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C009 &, C009 const &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C009 &, C009 const &, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C009 &, C009 const &, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C009 const &, C009 const, void >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C009 const &, C009 &, void >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C009 const &, C009 &, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C009 const &, C009 &, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C009 const &, C009 const &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C009 const &, C009 const &, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C009 const &, C009 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C009 const &, C009 const &, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C010, C010, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C010, C010 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C010, C010 const, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C010, C010 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C010, C010 &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C010, C010 &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C010, C010 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C010, C010 const &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C010 const, C010, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C010 const, C010, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C010 const, C010, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C010 const, C010, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C010 const, C010 const, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C010 const, C010 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C010 const, C010 const &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C010 &, C010, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C010 &, C010, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C010 &, C010 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C010 &, C010 const &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C010 &, C010 const &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C010 const &, C010, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C010 const &, C010, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C010 const &, C010 const, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C010 const &, C010 &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C010 const &, C010 &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C010 const &, C010 &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C010 const &, C010 const &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C011, C011, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C011, C011, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C011, C011, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C011, C011 const, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C011, C011 const, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C011, C011 &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C011, C011 &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C011, C011 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C011, C011 const &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C011, C011 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C011, C011 const &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C011 const, C011, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C011 const, C011, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C011 const, C011, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C011 const, C011 const, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C011 const, C011 const, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C011 const, C011 &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C011 const, C011 &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C011 const, C011 const &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C011 const, C011 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C011 &, C011, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C011 &, C011, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C011 &, C011, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C011 &, C011 const, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C011 &, C011 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C011 &, C011 &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C011 &, C011 &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C011 &, C011 &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C011 &, C011 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C011 &, C011 const &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C011 &, C011 const &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C011 const &, C011, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C011 const &, C011, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C011 const &, C011 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C011 const &, C011 const, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C011 const &, C011 &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C011 const &, C011 &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C011 const &, C011 &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C011 const &, C011 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C014, C014, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C014, C014, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C014, C014 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C014, C014 const, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C014, C014 &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C014, C014 &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C014, C014 &, ret & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C014, C014 &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C014, C014 const &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C014 const, C014, ret const >::value), 1); +TT_TEST_END diff --git a/libs/type_traits/test/has_binary_classes1_test.cpp b/libs/type_traits/test/has_binary_classes1_test.cpp new file mode 100644 index 0000000000..136e3b879d --- /dev/null +++ b/libs/type_traits/test/has_binary_classes1_test.cpp @@ -0,0 +1,263 @@ +// (C) Copyright 2009-2011 Frederic Bron. +// 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" + +#include <boost/type_traits/has_operator.hpp> +#include "has_binary_classes.hpp" + +TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME) + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C014 const, C014, ret & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C014 const, C014 const, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C014 const, C014 const, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C014 const, C014 const &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C014 const, C014 const &, ret & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C014 const, C014 const &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C014 &, C014, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C014 &, C014, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C014 &, C014 &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C014 &, C014 &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C014 &, C014 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C014 &, C014 const &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C014 &, C014 const &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C014 &, C014 const &, ret & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C014 &, C014 const &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C014 const &, C014, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C014 const &, C014, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C014 const &, C014, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C014 const &, C014 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C014 const &, C014 const, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C014 const &, C014 const, ret & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C014 const &, C014 &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C014 const &, C014 &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C014 const &, C014 &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C014 const &, C014 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C014 const &, C014 const &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C014 const &, C014 const &, ret & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C015, C015, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C015, C015, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C015, C015 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C015, C015 &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C015, C015 const &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C015 const, C015, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C015 const, C015, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C015 const, C015 const, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C015 const, C015 const, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C015 const, C015 &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C015 const, C015 &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C015 const, C015 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C015 &, C015, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C015 &, C015, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C015 &, C015 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C015 &, C015 const, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C015 &, C015 &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C015 const &, C015, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C015 const &, C015 &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C015 const &, C015 &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C015 const &, C015 const &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C015 const &, C015 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C036, C036, void >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C036, C036 const, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C036, C036 &, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C036, C036 &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C036, C036 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C036, C036 const &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C036, C036 const &, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C036 const, C036, void >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C036 const, C036, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C036 const, C036 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C036 const, C036 const, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C036 const, C036 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C036 const, C036 const &, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C036 &, C036, void >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C036 &, C036, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C036 &, C036 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C036 &, C036 const, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C036 &, C036 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C036 &, C036 &, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C036 &, C036 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C036 &, C036 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C036 const &, C036, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C036 const &, C036, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C036 const &, C036 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C036 const &, C036 const, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C036 const &, C036 &, void >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C036 const &, C036 &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C036 const &, C036 &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C036 const &, C036 &, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C036 const &, C036 const &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C036 const &, C036 const &, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C037, C037, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C037, C037, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C037, C037, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C037, C037 const, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C037, C037 const, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C037, C037 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C037, C037 &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C037, C037 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C037, C037 const &, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C037 const, C037, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C037 const, C037, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C037 const, C037, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C037 const, C037 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C037 const, C037 &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C037 const, C037 &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C037 const, C037 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C037 const, C037 const &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C037 const, C037 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C037 &, C037, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C037 &, C037, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C037 &, C037, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C037 &, C037, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C037 &, C037 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C037 &, C037 const, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C037 &, C037 &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C037 &, C037 &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C037 const &, C037, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C037 const &, C037, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C037 const &, C037 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C037 const &, C037 &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C037 const &, C037 &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C037 const &, C037 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C038, C038, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C038, C038, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C038, C038, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C038, C038 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C038, C038 &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C038, C038 &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C038, C038 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C038, C038 const &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C038, C038 const &, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C038, C038 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C038 const, C038, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C038 const, C038, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C038 const, C038 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C038 const, C038 const, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C038 const, C038 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C038 const, C038 &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C038 const, C038 &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C038 const, C038 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C038 const, C038 const &, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C038 const, C038 const &, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C038 &, C038, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C038 &, C038, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C038 &, C038 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C038 &, C038 &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C038 &, C038 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C038 &, C038 const &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C038 &, C038 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C038 const &, C038, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C038 const &, C038, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C038 const &, C038, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C038 const &, C038 &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C041, C041, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C041, C041 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C041, C041 const, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C041, C041 const, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C041, C041 &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C041, C041 &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C041, C041 const &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C041 const, C041, ret & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C041 const, C041 const, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C041 const, C041 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C041 const, C041 const, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C041 const, C041 &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C041 const, C041 const &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C041 const, C041 const &, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C041 &, C041 &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C041 &, C041 &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C041 &, C041 &, ret & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C041 &, C041 const &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C041 &, C041 const &, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C041 const &, C041, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C041 const &, C041 const, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C041 const &, C041 const, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C041 const &, C041 &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C041 const &, C041 &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C041 const &, C041 &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C041 const &, C041 &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C041 const &, C041 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C041 const &, C041 const &, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C042, C042, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C042, C042, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C042, C042, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C042, C042 const, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C042, C042 const, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C042, C042 &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C042, C042 &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C042, C042 &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C042, C042 const &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C042 const, C042, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C042 const, C042, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C042 const, C042, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C042 const, C042 const, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C042 const, C042 const, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C042 const, C042 &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C042 const, C042 const &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C042 &, C042, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C042 &, C042 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C042 &, C042 const, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C042 &, C042 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C042 &, C042 const &, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C042 &, C042 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C042 const &, C042, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C042 const &, C042, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C042 const &, C042 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C042 const &, C042 const, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C042 const &, C042 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C042 const &, C042 &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C042 const &, C042 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C042 const &, C042 const &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C042 const &, C042 const &, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C042 const &, C042 const &, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C045, C045 &, void >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C045, C045 &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C045, C045 const &, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C045 const, C045, void >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C045 const, C045, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C045 const, C045, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C045 const, C045 &, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C045 const, C045 &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C045 const, C045 &, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C045 const, C045 const &, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C045 const, C045 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C045 const, C045 const &, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C045 &, C045, void >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C045 &, C045, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C045 &, C045, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C045 &, C045, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C045 &, C045 const, void >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C045 &, C045 const, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C045 &, C045 &, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C045 &, C045 const &, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C045 const &, C045 const, void >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C045 const &, C045 const, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C045 const &, C045 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C045 const &, C045 const, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C045 const &, C045 const &, void >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C046, C046 &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C046, C046 &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C046, C046 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C046 const, C046, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C046 const, C046 const, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C046 const, C046 const, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C046 const, C046 const, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C046 const, C046 &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C046 const, C046 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C046 const, C046 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C046 &, C046 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C046 &, C046 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C046 &, C046 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C046 &, C046 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C046 &, C046 const &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C046 const &, C046, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C046 const &, C046, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C046 const &, C046 const, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C046 const &, C046 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C046 const &, C046 const, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C046 const &, C046 &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C046 const &, C046 &, ret const >::value), 1); +TT_TEST_END diff --git a/libs/type_traits/test/has_binary_classes2_test.cpp b/libs/type_traits/test/has_binary_classes2_test.cpp new file mode 100644 index 0000000000..4ce7f0b95e --- /dev/null +++ b/libs/type_traits/test/has_binary_classes2_test.cpp @@ -0,0 +1,263 @@ +// (C) Copyright 2009-2011 Frederic Bron. +// 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" + +#include <boost/type_traits/has_operator.hpp> +#include "has_binary_classes.hpp" + +TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME) + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C046 const &, C046 &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C046 const &, C046 &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C046 const &, C046 const &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C046 const &, C046 const &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C047, C047, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C047, C047, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C047, C047, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C047, C047 const, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C047, C047 &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C047, C047 const &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C047, C047 const &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C047 const, C047, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C047 const, C047, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C047 const, C047, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C047 const, C047 const, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C047 const, C047 &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C047 const, C047 &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C047 const, C047 &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C047 const, C047 const &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C047 const, C047 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C047 const, C047 const &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C047 &, C047, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C047 &, C047, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C047 &, C047 const, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C047 &, C047 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C047 &, C047 const, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C047 &, C047 &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C047 &, C047 &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C047 &, C047 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C047 const &, C047, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C047 const &, C047 const, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C047 const &, C047 &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C047 const &, C047 &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C047 const &, C047 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C047 const &, C047 const &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C047 const &, C047 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C050, C050, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C050, C050 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C050, C050 &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C050, C050 &, ret & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C050, C050 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C050, C050 const &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C050, C050 const &, ret & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C050 const, C050, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C050 const, C050, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C050 const, C050, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C050 const, C050 &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C050 const, C050 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C050 const, C050 const &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C050 const, C050 const &, ret & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C050 &, C050, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C050 &, C050, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C050 &, C050, ret & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C050 &, C050 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C050 &, C050 const, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C050 &, C050 const, ret & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C050 &, C050 const, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C050 &, C050 const &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C050 const &, C050, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C050 const &, C050, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C050 const &, C050 const, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C050 const &, C050 const, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C050 const &, C050 const, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C050 const &, C050 &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C050 const &, C050 &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C050 const &, C050 &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C050 const &, C050 const &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C050 const &, C050 const &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C050 const &, C050 const &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C051, C051, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C051, C051, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C051, C051, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C051, C051 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C051, C051 &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C051, C051 &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C051, C051 &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C051, C051 &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C051, C051 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C051, C051 const &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C051 const, C051, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C051 const, C051 &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C051 const, C051 &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C051 const, C051 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C051 const, C051 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C051 const, C051 const &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C051 &, C051, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C051 &, C051 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C051 &, C051 const, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C051 &, C051 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C051 &, C051 const, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C051 &, C051 const &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C051 const &, C051, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C051 const &, C051, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C051 const &, C051 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C051 const &, C051 const, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C051 const &, C051 &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C051 const &, C051 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C072, C072 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C072, C072 &, void >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C072, C072 &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C072, C072 &, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C072, C072 const &, void >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C072, C072 const &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C072, C072 const &, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C072, C072 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C072 const, C072, void >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C072 const, C072, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C072 const, C072, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C072 const, C072 const, void >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C072 const, C072 const, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C072 const, C072 const &, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C072 const, C072 const &, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C072 &, C072, void >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C072 &, C072, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C072 &, C072, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C072 &, C072 const, void >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C072 &, C072 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C072 &, C072 const, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C072 &, C072 &, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C072 &, C072 &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C072 &, C072 const &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C072 &, C072 const &, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C072 &, C072 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C072 const &, C072, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C072 const &, C072, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C072 const &, C072 const, void >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C072 const &, C072 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C072 const &, C072 const, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C072 const &, C072 &, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C072 const &, C072 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C072 const &, C072 const &, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C073, C073, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C073, C073, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C073, C073, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C073, C073 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C073, C073 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C073, C073 const, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C073, C073 &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C073, C073 const &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C073, C073 const &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C073 const, C073, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C073 const, C073 const, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C073 const, C073 &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C073 const, C073 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C073 const, C073 const &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C073 &, C073, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C073 &, C073, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C073 &, C073, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C073 &, C073 const, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C073 &, C073 &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C073 const &, C073, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C073 const &, C073, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C073 const &, C073, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C073 const &, C073 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C073 const &, C073 const, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C073 const &, C073 const, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C073 const &, C073 &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C073 const &, C073 const &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C073 const &, C073 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C074, C074, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C074, C074 const, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C074, C074 const, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C074, C074 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C074, C074 &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C074, C074 &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C074, C074 &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C074, C074 &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C074, C074 const &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C074, C074 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C074 const, C074, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C074 const, C074, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C074 const, C074 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C074 const, C074 const, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C074 const, C074 &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C074 const, C074 &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C074 const, C074 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C074 &, C074, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C074 &, C074, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C074 &, C074, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C074 &, C074, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C074 &, C074 const, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C074 &, C074 &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C074 &, C074 &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C074 &, C074 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C074 const &, C074, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C074 const &, C074, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C074 const &, C074 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C074 const &, C074 const, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C074 const &, C074 &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C074 const &, C074 &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C074 const &, C074 &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C074 const &, C074 &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C074 const &, C074 const &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C077, C077, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C077, C077 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C077, C077 const, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C077, C077 &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C077, C077 &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C077, C077 const &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C077, C077 const &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C077, C077 const &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C077 const, C077, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C077 const, C077, ret & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C077 const, C077 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C077 const, C077 const, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C077 const, C077 const, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C077 const, C077 const, ret & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C077 const, C077 const, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C077 const, C077 &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C077 const, C077 &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C077 const, C077 &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C077 const, C077 const &, ret & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C077 &, C077, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C077 &, C077 &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C077 &, C077 &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C077 &, C077 const &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C077 const &, C077, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C077 const &, C077, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C077 const &, C077, ret & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C077 const &, C077, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C077 const &, C077 const, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C077 const &, C077 const, ret & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C077 const &, C077 &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C077 const &, C077 &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C077 const &, C077 &, ret & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C077 const &, C077 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C077 const &, C077 const &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C077 const &, C077 const &, ret & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C077 const &, C077 const &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C078, C078, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C078, C078 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C078, C078 const, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C078, C078 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C078, C078 const, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C078, C078 &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C078, C078 &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C078, C078 &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C078, C078 const &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C078, C078 const &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C078, C078 const &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C078 const, C078, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C078 const, C078, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C078 const, C078, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C078 const, C078 const, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C078 const, C078 &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C078 const, C078 const &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C078 const, C078 const &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C078 &, C078, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C078 &, C078, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C078 &, C078 const, void >::value), 0); +TT_TEST_END diff --git a/libs/type_traits/test/has_binary_classes3_test.cpp b/libs/type_traits/test/has_binary_classes3_test.cpp new file mode 100644 index 0000000000..bf9355e726 --- /dev/null +++ b/libs/type_traits/test/has_binary_classes3_test.cpp @@ -0,0 +1,263 @@ +// (C) Copyright 2009-2011 Frederic Bron. +// 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" + +#include <boost/type_traits/has_operator.hpp> +#include "has_binary_classes.hpp" + +TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME) + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C078 &, C078 const, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C078 &, C078 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C078 &, C078 const, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C078 &, C078 &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C078 &, C078 &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C078 &, C078 &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C078 &, C078 const &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C078 &, C078 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C078 const &, C078, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C078 const &, C078 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C078 const &, C078 const, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C078 const &, C078 const, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C078 const &, C078 &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C078 const &, C078 &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C078 const &, C078 &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C078 const &, C078 const &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C078 const &, C078 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C081, C081, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C081, C081, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C081, C081, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C081, C081 const, void >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C081, C081 const, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C081, C081 const, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C081, C081 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C081, C081 &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C081, C081 &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C081, C081 const &, void >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C081, C081 const &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C081, C081 const &, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C081, C081 const &, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C081 const, C081, void >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C081 const, C081, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C081 const, C081, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C081 const, C081 const, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C081 const, C081 &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C081 const, C081 &, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C081 const, C081 &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C081 const, C081 const &, void >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C081 const, C081 const &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C081 const, C081 const &, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C081 const, C081 const &, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C081 &, C081, void >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C081 &, C081, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C081 &, C081, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C081 &, C081, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C081 &, C081 const, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C081 &, C081 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C081 &, C081 &, void >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C081 &, C081 &, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C081 &, C081 const &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C081 &, C081 const &, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C081 const &, C081 const, void >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C081 const &, C081 const, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C081 const &, C081 const, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C081 const &, C081 &, void >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C081 const &, C081 const &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C082, C082, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C082, C082, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C082, C082, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C082, C082 const, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C082, C082 &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C082, C082 const &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C082, C082 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C082 const, C082, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C082 const, C082 const, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C082 const, C082 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C082 const, C082 &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C082 const, C082 &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C082 const, C082 &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C082 const, C082 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C082 const, C082 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C082 &, C082, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C082 &, C082, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C082 &, C082, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C082 &, C082 const, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C082 &, C082 &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C082 &, C082 &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C082 &, C082 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C082 &, C082 const &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C082 &, C082 const &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C082 &, C082 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C082 const &, C082, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C082 const &, C082 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C082 const &, C082 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C082 const &, C082 const, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C082 const &, C082 &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C082 const &, C082 &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C082 const &, C082 &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C082 const &, C082 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C082 const &, C082 const &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C082 const &, C082 const &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C083, C083, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C083, C083, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C083, C083 const, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C083, C083 &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C083, C083 &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C083, C083 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C083, C083 const &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C083 const, C083, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C083 const, C083, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C083 const, C083, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C083 const, C083 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C083 const, C083 const, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C083 const, C083 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C083 const, C083 const, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C083 const, C083 &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C083 const, C083 const &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C083 const, C083 const &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C083 &, C083, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C083 &, C083, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C083 &, C083, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C083 &, C083 &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C083 &, C083 &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C083 &, C083 const &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C083 const &, C083, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C083 const &, C083, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C083 const &, C083, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C083 const &, C083 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C083 const &, C083 const, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C083 const &, C083 const, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C083 const &, C083 const &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C083 const &, C083 const &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C086, C086, ret & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C086, C086 const, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C086, C086 const, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C086, C086 &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C086, C086 &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C086, C086 &, ret & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C086, C086 const &, ret & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C086, C086 const &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C086 const, C086, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C086 const, C086, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C086 const, C086 const, ret & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C086 const, C086 &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C086 const, C086 &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C086 const, C086 &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C086 const, C086 &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C086 const, C086 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C086 const, C086 const &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C086 &, C086, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C086 &, C086 const, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C086 &, C086 const, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C086 &, C086 const, ret & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C086 &, C086 &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C086 &, C086 const &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C086 const &, C086 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C086 const &, C086 const, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C086 const &, C086 const, ret & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C086 const &, C086 &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C086 const &, C086 &, ret & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C086 const &, C086 &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C086 const &, C086 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C086 const &, C086 const &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C087, C087, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C087, C087, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C087, C087, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C087, C087 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C087, C087 const, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C087, C087 const, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C087, C087 const &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C087 const, C087, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C087 const, C087, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C087 const, C087 const, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C087 const, C087 &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C087 &, C087, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C087 &, C087, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C087 &, C087, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C087 &, C087 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C087 &, C087 const, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C087 &, C087 &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C087 const &, C087, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C087 const &, C087, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C087 const &, C087, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C087 const &, C087 const, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C087 const &, C087 &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C087 const &, C087 const &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C108, C108, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C108, C108, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C108, C108, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C108, C108, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C108, C108 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C108, C108 &, void >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C108, C108 &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C108, C108 &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C108, C108 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C108, C108 const &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C108 const, C108, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C108 const, C108, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C108 const, C108 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C108 const, C108 const, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C108 const, C108 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C108 const, C108 const &, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C108 const, C108 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C108 const, C108 const &, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C108 &, C108, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C108 &, C108 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C108 &, C108 const, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C108 &, C108 &, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C108 &, C108 &, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C108 &, C108 const &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C108 &, C108 const &, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C108 &, C108 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C108 const &, C108, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C108 const &, C108 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C108 const &, C108 const, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C108 const &, C108 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C108 const &, C108 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C109, C109, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C109, C109 const, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C109, C109 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C109, C109 const, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C109, C109 &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C109, C109 &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C109, C109 const &, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C109 const, C109, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C109 const, C109, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C109 const, C109, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C109 const, C109 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C109 const, C109 const, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C109 const, C109 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C109 const, C109 const, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C109 const, C109 &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C109 const, C109 &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C109 const, C109 &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C109 const, C109 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C109 const, C109 const &, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C109 const, C109 const &, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C109 &, C109, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C109 &, C109 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C109 &, C109 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C109 &, C109 &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C109 &, C109 &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C109 &, C109 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C109 &, C109 const &, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C109 const &, C109, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C109 const &, C109 const, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C109 const &, C109 const, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C109 const &, C109 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C109 const &, C109 &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C109 const &, C109 &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C109 const &, C109 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C109 const &, C109 const &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C109 const &, C109 const &, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C110, C110, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C110, C110, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C110, C110, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C110, C110 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C110, C110 &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C110, C110 const &, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C110 const, C110, ret >::value), 1); +TT_TEST_END diff --git a/libs/type_traits/test/has_binary_classes4_test.cpp b/libs/type_traits/test/has_binary_classes4_test.cpp new file mode 100644 index 0000000000..50b8688a1a --- /dev/null +++ b/libs/type_traits/test/has_binary_classes4_test.cpp @@ -0,0 +1,263 @@ +// (C) Copyright 2009-2011 Frederic Bron. +// 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" + +#include <boost/type_traits/has_operator.hpp> +#include "has_binary_classes.hpp" + +TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME) + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C110 const, C110, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C110 const, C110, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C110 const, C110, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C110 const, C110 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C110 const, C110 &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C110 const, C110 &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C110 const, C110 &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C110 const, C110 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C110 const, C110 const &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C110 const, C110 const &, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C110 &, C110, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C110 &, C110, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C110 &, C110 &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C110 &, C110 &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C110 &, C110 &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C110 &, C110 const &, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C110 const &, C110, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C110 const &, C110, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C110 const &, C110 const, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C110 const &, C110 const, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C110 const &, C110 &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C110 const &, C110 &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C110 const &, C110 const &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C110 const &, C110 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C110 const &, C110 const &, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C113, C113, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C113, C113, ret & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C113, C113, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C113, C113 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C113, C113 const, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C113, C113 &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C113, C113 &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C113, C113 &, ret & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C113, C113 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C113, C113 const &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C113, C113 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C113 const, C113, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C113 const, C113 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C113 const, C113 const, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C113 const, C113 const, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C113 const, C113 &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C113 const, C113 &, ret & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C113 const, C113 const &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C113 const, C113 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C113 &, C113, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C113 &, C113, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C113 &, C113 const, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C113 &, C113 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C113 &, C113 const &, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C113 &, C113 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C113 &, C113 const &, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C113 const &, C113, ret & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C113 const &, C113 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C113 const &, C113 const, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C113 const &, C113 &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C113 const &, C113 &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C113 const &, C113 const &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C113 const &, C113 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C113 const &, C113 const &, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C114, C114 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C114, C114 const, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C114, C114 const, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C114, C114 &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C114, C114 &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C114, C114 &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C114, C114 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C114, C114 const &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C114, C114 const &, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C114, C114 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C114, C114 const &, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C114 const, C114, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C114 const, C114, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C114 const, C114 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C114 const, C114 const, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C114 const, C114 const, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C114 const, C114 &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C114 const, C114 &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C114 const, C114 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C114 &, C114, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C114 &, C114 const, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C114 &, C114 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C114 &, C114 const &, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C114 const &, C114, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C114 const &, C114, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C114 const &, C114 &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C114 const &, C114 &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C114 const &, C114 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C114 const &, C114 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C117, C117, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C117, C117, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C117, C117 const, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C117, C117 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C117, C117 &, void >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C117, C117 &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C117 const, C117, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C117 const, C117, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C117 const, C117 const, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C117 const, C117 const, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C117 const, C117 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C117 const, C117 &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C117 const, C117 const &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C117 &, C117, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C117 &, C117 const, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C117 &, C117 &, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C117 &, C117 const &, void >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C117 &, C117 const &, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C117 &, C117 const &, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C117 const &, C117, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C117 const &, C117 const, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C117 const &, C117 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C117 const &, C117 const, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C117 const &, C117 &, void >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C117 const &, C117 &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C117 const &, C117 &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C117 const &, C117 &, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C117 const &, C117 const &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C117 const &, C117 const &, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C118, C118, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C118, C118, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C118, C118 const, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C118, C118 const, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C118, C118 &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C118, C118 &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C118, C118 &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C118, C118 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C118, C118 const &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C118, C118 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C118 const, C118, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C118 const, C118 const, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C118 const, C118 const, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C118 const, C118 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C118 const, C118 &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C118 const, C118 &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C118 &, C118, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C118 &, C118, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C118 &, C118, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C118 &, C118 const, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C118 &, C118 &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C118 &, C118 &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C118 &, C118 &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C118 &, C118 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C118 &, C118 const &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C118 const &, C118, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C118 const &, C118, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C118 const &, C118 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C118 const &, C118 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C118 const &, C118 const, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C118 const &, C118 &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C118 const &, C118 &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C118 const &, C118 &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C118 const &, C118 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C118 const &, C118 const &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C119, C119, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C119, C119, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C119, C119 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C119, C119 const, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C119, C119 const, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C119, C119 &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C119, C119 &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C119, C119 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C119, C119 const &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C119, C119 const &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C119 const, C119, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C119 const, C119 &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C119 const, C119 &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C119 const, C119 const &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C119 const, C119 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C119 const, C119 const &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C119 &, C119, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C119 &, C119 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C119 &, C119 const, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C119 &, C119 const, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C119 &, C119 &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C119 &, C119 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C119 &, C119 const &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C119 &, C119 const &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C119 &, C119 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C119 &, C119 const &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C119 const &, C119, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C119 const &, C119, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C119 const &, C119 const, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C119 const &, C119 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C119 const &, C119 const, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C119 const &, C119 &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C119 const &, C119 &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C119 const &, C119 const &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C119 const &, C119 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C122, C122, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C122, C122 const, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C122, C122 &, ret & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C122, C122 const &, ret & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C122 const, C122, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C122 const, C122, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C122 const, C122 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C122 const, C122 const, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C122 const, C122 const, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C122 const, C122 &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C122 const, C122 &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C122 const, C122 &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C122 const, C122 const &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C122 &, C122 const, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C122 &, C122 const &, ret & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C122 &, C122 const &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C122 const &, C122, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C122 const &, C122, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C122 const &, C122, ret & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C122 const &, C122 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C122 const &, C122 const, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C122 const &, C122 const, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C122 const &, C122 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C122 const &, C122 const &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C122 const &, C122 const &, ret & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C123, C123, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C123, C123, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C123, C123 const, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C123, C123 const &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C123, C123 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C123 const, C123 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C123 const, C123 &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C123 const, C123 &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C123 const, C123 &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C123 const, C123 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C123 const, C123 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C123 const, C123 const &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C123 &, C123, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C123 &, C123 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C123 &, C123 const, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C123 &, C123 &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C123 &, C123 const &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C123 const &, C123, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C123 const &, C123, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C123 const &, C123 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C123 const &, C123 const, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C123 const &, C123 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C123 const &, C123 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C123 const &, C123 const &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C288, C288, void >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C288, C288, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C288, C288, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C288, C288 &, void >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C288, C288 &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C288, C288 &, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C288, C288 &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C288, C288 &, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C288, C288 const &, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C288 const, C288, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C288 const, C288, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C288 const, C288 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C288 const, C288 &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C288 const, C288 &, ret const >::value), 0); +TT_TEST_END diff --git a/libs/type_traits/test/has_binary_classes5_test.cpp b/libs/type_traits/test/has_binary_classes5_test.cpp new file mode 100644 index 0000000000..ffed104d8b --- /dev/null +++ b/libs/type_traits/test/has_binary_classes5_test.cpp @@ -0,0 +1,263 @@ +// (C) Copyright 2009-2011 Frederic Bron. +// 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" + +#include <boost/type_traits/has_operator.hpp> +#include "has_binary_classes.hpp" + +TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME) + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C288 const, C288 &, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C288 const, C288 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C288 &, C288, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C288 &, C288, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C288 &, C288, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C288 &, C288 const, void >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C288 &, C288 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C288 &, C288 const, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C288 &, C288 &, void >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C288 &, C288 &, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C288 &, C288 const &, void >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C288 &, C288 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C288 &, C288 const &, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C288 const &, C288, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C288 const &, C288, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C288 const &, C288, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C288 const &, C288 const, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C288 const &, C288 &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C288 const &, C288 &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C288 const &, C288 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C289, C289, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C289, C289 const, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C289, C289 const, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C289, C289 &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C289 const, C289, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C289 const, C289, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C289 const, C289 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C289 const, C289 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C289 const, C289 &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C289 const, C289 &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C289 const, C289 &, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C289 const, C289 &, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C289 const, C289 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C289 const, C289 const &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C289 &, C289, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C289 &, C289, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C289 &, C289 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C289 &, C289 const, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C289 &, C289 &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C289 &, C289 const &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C289 &, C289 const &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C289 &, C289 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C289 const &, C289, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C289 const &, C289 const, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C289 const &, C289 &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C289 const &, C289 &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C290, C290, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C290, C290, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C290, C290 &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C290, C290 &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C290, C290 &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C290, C290 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C290 const, C290, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C290 const, C290, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C290 const, C290 const, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C290 const, C290 &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C290 const, C290 &, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C290 const, C290 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C290 const, C290 const &, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C290 &, C290, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C290 &, C290, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C290 &, C290, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C290 &, C290 const, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C290 &, C290 const, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C290 &, C290 &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C290 &, C290 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C290 const &, C290, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C290 const &, C290, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C290 const &, C290 const, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C290 const &, C290 const, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C290 const &, C290 &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C290 const &, C290 &, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C290 const &, C290 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C290 const &, C290 const &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C290 const &, C290 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C290 const &, C290 const &, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C293, C293, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C293, C293, ret & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C293, C293, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C293, C293 const, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C293, C293 const, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C293, C293 &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C293, C293 &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C293, C293 &, ret & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C293, C293 const &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C293 const, C293, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C293 const, C293 const, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C293 const, C293 const, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C293 const, C293 &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C293 const, C293 &, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C293 const, C293 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C293 const, C293 const &, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C293 &, C293, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C293 &, C293, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C293 &, C293 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C293 &, C293 const, ret & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C293 &, C293 &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C293 &, C293 &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C293 &, C293 const &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C293 &, C293 const &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C293 &, C293 const &, ret & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C293 const &, C293 const, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C293 const &, C293 const, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C293 const &, C293 &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C293 const &, C293 &, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C293 const &, C293 &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C293 const &, C293 const &, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C293 const &, C293 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C294, C294, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C294, C294, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C294, C294 const, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C294, C294 const, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C294, C294 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C294, C294 &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C294, C294 &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C294, C294 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C294, C294 const &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C294, C294 const &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C294, C294 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C294, C294 const &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C294 const, C294, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C294 const, C294, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C294 const, C294 const, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C294 const, C294 &, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C294 const, C294 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C294 const, C294 const &, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C294 const, C294 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C294 const, C294 const &, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C294 &, C294, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C294 &, C294, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C294 &, C294, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C294 &, C294 const, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C294 &, C294 const, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C294 &, C294 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C294 &, C294 &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C294 &, C294 &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C294 &, C294 const &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C294 &, C294 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C294 const &, C294, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C294 const &, C294, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C294 const &, C294, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C294 const &, C294, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C294 const &, C294 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C294 const &, C294 const, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C294 const &, C294 const, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C294 const &, C294 &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C294 const &, C294 &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C294 const &, C294 &, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C294 const &, C294 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C294 const &, C294 const &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C294 const &, C294 const &, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C297, C297, void >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C297, C297, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C297, C297, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C297, C297 &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C297, C297 &, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C297, C297 &, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C297, C297 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C297 const, C297, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C297 const, C297, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C297 const, C297, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C297 const, C297 &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C297 const, C297 &, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C297 const, C297 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C297 const, C297 const &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C297 const, C297 const &, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C297 &, C297, void >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C297 &, C297, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C297 &, C297, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C297 &, C297 const, void >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C297 &, C297 const, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C297 &, C297 const, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C297 &, C297 &, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C297 &, C297 const &, void >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C297 &, C297 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C297 const &, C297, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C297 const &, C297, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C297 const &, C297 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C297 const &, C297 &, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C297 const &, C297 const &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C297 const &, C297 const &, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C298, C298, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C298, C298, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C298, C298, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C298, C298 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C298, C298 const, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C298, C298 const, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C298, C298 &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C298, C298 &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C298, C298 &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C298, C298 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C298, C298 const &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C298, C298 const &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C298 const, C298, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C298 const, C298, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C298 const, C298 const, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C298 const, C298 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C298 const, C298 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C298 &, C298, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C298 &, C298, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C298 &, C298 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C298 &, C298 &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C298 &, C298 const &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C298 const &, C298, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C298 const &, C298, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C298 const &, C298, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C298 const &, C298, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C298 const &, C298 &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C298 const &, C298 &, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C298 const &, C298 &, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C298 const &, C298 const &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C298 const &, C298 const &, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C299, C299, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C299, C299, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C299, C299 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C299, C299 const, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C299, C299 &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C299, C299 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C299, C299 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C299 const, C299 &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C299 const, C299 &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C299 const, C299 &, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C299 const, C299 const &, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C299 &, C299, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C299 &, C299 const, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C299 &, C299 const, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C299 &, C299 const &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C299 &, C299 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C299 &, C299 const &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C299 const &, C299, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C299 const &, C299, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C299 const &, C299, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C299 const &, C299 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C299 const &, C299 const, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C299 const &, C299 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C299 const &, C299 const, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C299 const &, C299 &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C299 const &, C299 &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C299 const &, C299 &, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C299 const &, C299 const &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C302, C302 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C302, C302 const, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C302, C302 const, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C302, C302 const, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C302, C302 &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C302, C302 &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C302, C302 &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C302, C302 const &, ret & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C302 const, C302, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C302 const, C302, ret const >::value), 0); +TT_TEST_END diff --git a/libs/type_traits/test/has_binary_classes6_test.cpp b/libs/type_traits/test/has_binary_classes6_test.cpp new file mode 100644 index 0000000000..c9f67ab794 --- /dev/null +++ b/libs/type_traits/test/has_binary_classes6_test.cpp @@ -0,0 +1,263 @@ +// (C) Copyright 2009-2011 Frederic Bron. +// 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" + +#include <boost/type_traits/has_operator.hpp> +#include "has_binary_classes.hpp" + +TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME) + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C302 const, C302, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C302 const, C302, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C302 const, C302 const, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C302 const, C302 const, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C302 const, C302 &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C302 const, C302 &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C302 const, C302 &, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C302 const, C302 const &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C302 const, C302 const &, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C302 const, C302 const &, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C302 &, C302, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C302 &, C302 const, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C302 &, C302 &, ret & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C302 &, C302 const &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C302 &, C302 const &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C302 const &, C302, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C302 const &, C302, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C302 const &, C302 const, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C302 const &, C302 const, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C302 const &, C302 &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C302 const &, C302 &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C302 const &, C302 &, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C302 const &, C302 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C302 const &, C302 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C303, C303, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C303, C303, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C303, C303 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C303, C303 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C303, C303 &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C303, C303 &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C303, C303 &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C303, C303 &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C303, C303 const &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C303, C303 const &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C303 const, C303, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C303 const, C303, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C303 const, C303, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C303 const, C303 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C303 const, C303 const, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C303 const, C303 const, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C303 const, C303 &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C303 const, C303 &, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C303 const, C303 &, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C303 &, C303, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C303 &, C303, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C303 &, C303 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C303 &, C303 &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C303 &, C303 &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C303 &, C303 &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C303 &, C303 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C303 &, C303 const &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C303 &, C303 const &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C303 const &, C303, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C303 const &, C303, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C303 const &, C303 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C303 const &, C303 const, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C303 const &, C303 const, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C303 const &, C303 &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C303 const &, C303 &, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C303 const &, C303 &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C303 const &, C303 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C303 const &, C303 const &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C303 const &, C303 const &, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C324, C324, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C324, C324, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C324, C324, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C324, C324 const, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C324, C324 const, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C324, C324 &, void >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C324, C324 &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C324, C324 const &, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C324, C324 const &, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C324 const, C324, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C324 const, C324, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C324 const, C324 const, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C324 const, C324 const, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C324 const, C324 &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C324 const, C324 &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C324 const, C324 &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C324 const, C324 &, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C324 const, C324 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C324 &, C324, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C324 &, C324, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C324 &, C324 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C324 &, C324 const, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C324 &, C324 &, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C324 &, C324 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C324 &, C324 const &, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C324 &, C324 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C324 const &, C324, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C324 const &, C324, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C324 const &, C324, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C324 const &, C324 const, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C324 const &, C324 &, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C324 const &, C324 &, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C324 const &, C324 const &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C324 const &, C324 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C324 const &, C324 const &, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C325, C325, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C325, C325 const, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C325, C325 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C325, C325 const &, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C325 const, C325, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C325 const, C325, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C325 const, C325 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C325 const, C325 const, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C325 const, C325 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C325 const, C325 const, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C325 const, C325 &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C325 const, C325 const &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C325 const, C325 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C325 const, C325 const &, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C325 &, C325, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C325 &, C325 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C325 &, C325 &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C325 &, C325 const &, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C325 &, C325 const &, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C325 const &, C325, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C325 const &, C325, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C325 const &, C325, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C325 const &, C325 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C325 const &, C325 &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C325 const &, C325 &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C325 const &, C325 const &, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C326, C326, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C326, C326, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C326, C326 const, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C326, C326 const, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C326, C326 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C326, C326 &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C326, C326 const &, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C326 const, C326, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C326 const, C326, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C326 const, C326 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C326 const, C326 const, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C326 const, C326 &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C326 const, C326 &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C326 const, C326 &, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C326 const, C326 &, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C326 const, C326 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C326 &, C326, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C326 &, C326, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C326 &, C326 const, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C326 &, C326 &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C326 &, C326 &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C326 &, C326 &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C326 &, C326 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C326 &, C326 const &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C326 &, C326 const &, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C326 &, C326 const &, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C326 const &, C326, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C326 const &, C326 &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C326 const &, C326 &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C326 const &, C326 const &, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C326 const &, C326 const &, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C329, C329, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C329, C329, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C329, C329 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C329, C329 const, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C329, C329 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C329, C329 &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C329, C329 &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C329, C329 &, ret & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C329, C329 const &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C329, C329 const &, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C329 const, C329, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C329 const, C329, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C329 const, C329 const, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C329 const, C329 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C329 const, C329 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C329 const, C329 const &, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C329 &, C329, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C329 &, C329, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C329 &, C329 const, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C329 &, C329 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C329 &, C329 &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C329 &, C329 &, ret & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C329 &, C329 &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C329 &, C329 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C329 &, C329 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C329 const &, C329 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C329 const &, C329 &, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C329 const &, C329 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C330, C330, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C330, C330, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C330, C330, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C330, C330 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C330, C330 const, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C330, C330 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C330, C330 &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C330, C330 const &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C330, C330 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C330, C330 const &, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C330 const, C330, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C330 const, C330, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C330 const, C330 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C330 const, C330 &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C330 const, C330 &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C330 const, C330 const &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C330 &, C330, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C330 &, C330, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C330 &, C330 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C330 &, C330 const, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C330 &, C330 &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C330 &, C330 &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C330 &, C330 &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C330 &, C330 const &, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C330 &, C330 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C330 &, C330 const &, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C330 const &, C330 const, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C330 const &, C330 &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C330 const &, C330 const &, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C333, C333, void >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C333, C333, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C333, C333, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C333, C333 const, void >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C333, C333 const, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C333, C333 const, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C333, C333 &, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C333, C333 const &, void >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C333 const, C333 const, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C333 const, C333 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C333 const, C333 const, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C333 const, C333 &, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C333 const, C333 const &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C333 const, C333 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C333 &, C333, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C333 &, C333, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C333 &, C333, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C333 &, C333 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C333 &, C333 &, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C333 &, C333 const &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C333 &, C333 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C333 const &, C333, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C333 const &, C333, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C333 const &, C333 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C333 const &, C333 &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C333 const &, C333 &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C333 const &, C333 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C333 const &, C333 const &, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C333 const &, C333 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C334, C334, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C334, C334 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C334, C334 &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C334, C334 &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C334, C334 &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C334, C334 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C334, C334 const &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C334, C334 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C334 const, C334, ret const >::value), 0); +TT_TEST_END diff --git a/libs/type_traits/test/has_binary_classes7_test.cpp b/libs/type_traits/test/has_binary_classes7_test.cpp new file mode 100644 index 0000000000..25802d2148 --- /dev/null +++ b/libs/type_traits/test/has_binary_classes7_test.cpp @@ -0,0 +1,263 @@ +// (C) Copyright 2009-2011 Frederic Bron. +// 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" + +#include <boost/type_traits/has_operator.hpp> +#include "has_binary_classes.hpp" + +TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME) + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C334 const, C334 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C334 const, C334 const, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C334 const, C334 &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C334 const, C334 const &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C334 const, C334 const &, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C334 &, C334, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C334 &, C334, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C334 &, C334, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C334 &, C334 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C334 &, C334 const, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C334 &, C334 &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C334 &, C334 &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C334 &, C334 &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C334 &, C334 &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C334 &, C334 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C334 &, C334 const &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C334 &, C334 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C334 const &, C334, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C334 const &, C334, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C334 const &, C334, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C334 const &, C334, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C334 const &, C334 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C334 const &, C334 const, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C334 const &, C334 &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C334 const &, C334 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C335, C335, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C335, C335 &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C335, C335 &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C335, C335 const &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C335, C335 const &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C335 const, C335, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C335 const, C335, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C335 const, C335 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C335 const, C335 const, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C335 const, C335 const, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C335 const, C335 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C335 const, C335 &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C335 const, C335 &, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C335 const, C335 &, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C335 const, C335 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C335 const, C335 const &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C335 const, C335 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C335 &, C335, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C335 &, C335, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C335 &, C335, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C335 &, C335 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C335 &, C335 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C335 &, C335 &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C335 &, C335 &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C335 &, C335 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C335 &, C335 const &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C335 const &, C335, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C335 const &, C335, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C335 const &, C335 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C335 const &, C335 const, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C335 const &, C335 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C335 const &, C335 &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C335 const &, C335 &, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C335 const &, C335 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C335 const &, C335 const &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C335 const &, C335 const &, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C335 const &, C335 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C338, C338, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C338, C338, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C338, C338, ret & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C338, C338 const, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C338, C338 &, ret & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C338, C338 &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C338, C338 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C338 const, C338, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C338 const, C338, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C338 const, C338, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C338 const, C338 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C338 const, C338 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C338 const, C338 &, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C338 const, C338 &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C338 const, C338 &, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C338 const, C338 const &, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C338 &, C338, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C338 &, C338 const, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C338 &, C338 &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C338 &, C338 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C338 &, C338 const &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C338 &, C338 const &, ret & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C338 const &, C338, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C338 const &, C338 const, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C338 const &, C338 &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C338 const &, C338 &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C338 const &, C338 &, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C338 const &, C338 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C338 const &, C338 const &, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C339, C339, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C339, C339 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C339, C339 &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C339, C339 &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C339, C339 &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C339, C339 const &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C339, C339 const &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C339 const, C339, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C339 const, C339 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C339 const, C339 const, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C339 const, C339 &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C339 const, C339 &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C339 const, C339 &, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C339 const, C339 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C339 const, C339 const &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C339 const, C339 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C339 const, C339 const &, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C339 &, C339, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C339 &, C339, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C339 &, C339 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C339 &, C339 const, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C339 &, C339 &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C339 &, C339 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C339 &, C339 const &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C339 &, C339 const &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C339 &, C339 const &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C339 const &, C339, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C339 const &, C339, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C339 const &, C339 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C339 const &, C339 const, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C339 const &, C339 &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C339 const &, C339 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C339 const &, C339 const &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C339 const &, C339 const &, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C360, C360, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C360, C360 &, void >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C360, C360 &, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C360, C360 &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C360, C360 const &, void >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C360 const, C360, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C360 const, C360 const, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C360 const, C360 &, void >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C360 const, C360 &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C360 &, C360, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C360 &, C360 const, void >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C360 &, C360 const, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C360 &, C360 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C360 &, C360 &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C360 &, C360 &, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C360 &, C360 &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C360 &, C360 const &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C360 const &, C360, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C360 const &, C360, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C360 const &, C360 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C360 const &, C360 &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C360 const &, C360 const &, void >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C360 const &, C360 const &, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C360 const &, C360 const &, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C361, C361, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C361, C361, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C361, C361 const, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C361, C361 &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C361, C361 &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C361, C361 const &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C361 const, C361, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C361 const, C361, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C361 const, C361 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C361 const, C361 const, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C361 const, C361 const, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C361 const, C361 &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C361 const, C361 &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C361 const, C361 &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C361 &, C361, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C361 &, C361, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C361 &, C361 const, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C361 &, C361 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C361 &, C361 &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C361 &, C361 &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C361 &, C361 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C361 &, C361 const &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C361 &, C361 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C361 const &, C361, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C361 const &, C361, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C361 const &, C361 const, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C361 const &, C361 const, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C361 const &, C361 &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C361 const &, C361 &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C361 const &, C361 &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C361 const &, C361 const &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C361 const &, C361 const &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C361 const &, C361 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C361 const &, C361 const &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C362, C362, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C362, C362, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C362, C362 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C362, C362 &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C362, C362 &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C362, C362 const &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C362, C362 const &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C362, C362 const &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C362 const, C362, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C362 const, C362, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C362 const, C362, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C362 const, C362 const, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C362 const, C362 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C362 const, C362 const, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C362 const, C362 &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C362 const, C362 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C362 const, C362 const &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C362 &, C362 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C362 &, C362 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C362 &, C362 const, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C362 &, C362 const &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C362 &, C362 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C362 &, C362 const &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C362 const &, C362, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C362 const &, C362, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C362 const &, C362 const, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C362 const &, C362 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C362 const &, C362 &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C362 const &, C362 &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C362 const &, C362 const &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C362 const &, C362 const &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C365, C365, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C365, C365, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C365, C365 const, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C365, C365 &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C365, C365 &, ret & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C365, C365 const &, ret & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C365 const, C365, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C365 const, C365, ret & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C365 const, C365, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C365 const, C365 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C365 const, C365 const, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C365 const, C365 const, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C365 const, C365 &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C365 const, C365 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C365 const, C365 const &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C365 &, C365, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C365 &, C365, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C365 &, C365, ret & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C365 &, C365 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C365 &, C365 &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C365 &, C365 const &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C365 &, C365 const &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C365 const &, C365 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C365 const &, C365 const, ret & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C365 const &, C365 &, ret & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C365 const &, C365 const &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C366, C366, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C366, C366, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C366, C366, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C366, C366 const, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C366, C366 &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C366, C366 &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C366, C366 &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C366 const, C366, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C366 const, C366, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C366 const, C366, ret const & >::value), 1); +TT_TEST_END diff --git a/libs/type_traits/test/has_binary_classes8_test.cpp b/libs/type_traits/test/has_binary_classes8_test.cpp new file mode 100644 index 0000000000..c1eac81e01 --- /dev/null +++ b/libs/type_traits/test/has_binary_classes8_test.cpp @@ -0,0 +1,263 @@ +// (C) Copyright 2009-2011 Frederic Bron. +// 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" + +#include <boost/type_traits/has_operator.hpp> +#include "has_binary_classes.hpp" + +TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME) + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C366 const, C366 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C366 const, C366 const, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C366 const, C366 const, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C366 const, C366 const, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C366 const, C366 const &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C366 &, C366, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C366 &, C366, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C366 &, C366, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C366 &, C366, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C366 &, C366 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C366 &, C366 const, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C366 &, C366 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C366 &, C366 &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C366 &, C366 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C366 &, C366 const &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C366 const &, C366, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C366 const &, C366, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C366 const &, C366, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C366 const &, C366 const, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C366 const &, C366 const, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C366 const &, C366 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C366 const &, C366 &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C366 const &, C366 &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C366 const &, C366 &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C366 const &, C366 const &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C369, C369, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C369, C369, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C369, C369, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C369, C369, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C369, C369 const, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C369, C369 const, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C369, C369 &, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C369, C369 &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C369 const, C369, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C369 const, C369 const, void >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C369 const, C369 const, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C369 const, C369 const, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C369 const, C369 &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C369 const, C369 &, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C369 const, C369 const &, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C369 &, C369, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C369 &, C369, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C369 &, C369, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C369 &, C369 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C369 &, C369 &, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C369 &, C369 &, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C369 &, C369 const &, void >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C369 const &, C369, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C369 const &, C369, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C369 const &, C369, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C369 const &, C369 const, void >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C369 const &, C369 const, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C369 const &, C369 &, void >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C369 const &, C369 &, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C369 const &, C369 &, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C370, C370, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C370, C370 const, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C370, C370 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C370, C370 const, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C370, C370 &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C370, C370 const &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C370, C370 const &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C370, C370 const &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C370 const, C370 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C370 const, C370 const, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C370 const, C370 &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C370 const, C370 &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C370 const, C370 const &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C370 const, C370 const &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C370 &, C370, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C370 &, C370 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C370 &, C370 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C370 &, C370 &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C370 &, C370 &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C370 &, C370 &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C370 &, C370 const &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C370 &, C370 const &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C370 const &, C370, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C370 const &, C370, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C370 const &, C370, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C370 const &, C370 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C370 const &, C370 const, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C370 const &, C370 &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C370 const &, C370 &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C370 const &, C370 const &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C370 const &, C370 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C371, C371, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C371, C371 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C371, C371 const, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C371, C371 &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C371, C371 &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C371, C371 &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C371, C371 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C371, C371 const &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C371, C371 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C371 const, C371 const, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C371 const, C371 &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C371 const, C371 const &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C371 &, C371, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C371 &, C371, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C371 &, C371 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C371 &, C371 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C371 &, C371 &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C371 &, C371 &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C371 &, C371 &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C371 &, C371 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C371 &, C371 const &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C371 &, C371 const &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C371 &, C371 const &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C371 const &, C371, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C371 const &, C371, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C371 const &, C371 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C371 const &, C371 const, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C371 const &, C371 const, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C371 const &, C371 &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C371 const &, C371 &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C371 const &, C371 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C371 const &, C371 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C374, C374, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C374, C374, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C374, C374 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C374, C374 const, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C374, C374 &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C374, C374 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C374, C374 const &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C374, C374 const &, ret & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C374, C374 const &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C374 const, C374, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C374 const, C374, ret & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C374 const, C374, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C374 const, C374 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C374 const, C374 const, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C374 const, C374 const, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C374 const, C374 const, ret & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C374 const, C374 const, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C374 const, C374 &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C374 const, C374 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C374 const, C374 const &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C374 &, C374, ret & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C374 &, C374 const, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C374 &, C374 const, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C374 &, C374 const, ret & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C374 &, C374 const, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C374 &, C374 const &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C374 &, C374 const &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C374 const &, C374, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C374 const &, C374, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C374 const &, C374 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C374 const &, C374 const &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C375, C375, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C375, C375, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C375, C375, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C375, C375 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C375, C375 const, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C375, C375 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C375, C375 &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C375, C375 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C375, C375 const &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C375 const, C375, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C375 const, C375, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C375 const, C375, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C375 const, C375, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C375 const, C375 &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C375 const, C375 &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C375 const, C375 const &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C375 const, C375 const &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C375 const, C375 const &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C375 &, C375, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C375 &, C375, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C375 &, C375, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C375 &, C375, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C375 &, C375 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C375 &, C375 const, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C375 &, C375 const, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C375 &, C375 &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C375 &, C375 &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C375 &, C375 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C375 &, C375 const &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C375 &, C375 const &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C375 const &, C375, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C375 const &, C375 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C375 const &, C375 &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C375 const &, C375 &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C375 const &, C375 &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C375 const &, C375 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C396, C396, void >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C396, C396, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C396, C396, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C396, C396, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C396, C396 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C396, C396 const, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C396, C396 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C396, C396 &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C396, C396 &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C396, C396 &, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C396, C396 const &, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C396 const, C396, void >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C396 const, C396, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C396 const, C396, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C396 const, C396 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C396 const, C396 const, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C396 const, C396 const, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C396 const, C396 &, void >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C396 const, C396 &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C396 const, C396 &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C396 const, C396 const &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C396 const, C396 const &, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C396 &, C396, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C396 &, C396 const, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C396 &, C396 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C396 &, C396 &, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C396 &, C396 &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C396 &, C396 &, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C396 &, C396 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C396 &, C396 const &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C396 &, C396 const &, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C396 &, C396 const &, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C396 const &, C396, void >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C396 const &, C396, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C396 const &, C396, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C396 const &, C396 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C396 const &, C396 const &, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C397, C397, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C397, C397 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C397, C397 &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C397, C397 &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C397, C397 const &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C397, C397 const &, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C397 const, C397, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C397 const, C397, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C397 const, C397 const, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C397 const, C397 const, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C397 const, C397 &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C397 const, C397 &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C397 const, C397 &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C397 const, C397 &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C397 const, C397 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C397 &, C397, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C397 &, C397, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C397 &, C397 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C397 &, C397 const, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C397 &, C397 &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C397 &, C397 &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C397 &, C397 &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C397 &, C397 const &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C397 const &, C397, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C397 const &, C397, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C397 const &, C397 const, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C397 const &, C397 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C397 const &, C397 const, ret const & >::value), 0); +TT_TEST_END diff --git a/libs/type_traits/test/has_binary_classes9_test.cpp b/libs/type_traits/test/has_binary_classes9_test.cpp new file mode 100644 index 0000000000..3f9d639190 --- /dev/null +++ b/libs/type_traits/test/has_binary_classes9_test.cpp @@ -0,0 +1,263 @@ +// (C) Copyright 2009-2011 Frederic Bron. +// 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" + +#include <boost/type_traits/has_operator.hpp> +#include "has_binary_classes.hpp" + +TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME) + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C397 const &, C397 &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C397 const &, C397 &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C397 const &, C397 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C397 const &, C397 const &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C398, C398, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C398, C398, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C398, C398, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C398, C398, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C398, C398 const, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C398, C398 &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C398, C398 &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C398, C398 const &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C398, C398 const &, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C398 const, C398, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C398 const, C398, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C398 const, C398 const, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C398 const, C398 &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C398 const, C398 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C398 const, C398 const &, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C398 &, C398, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C398 &, C398, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C398 &, C398, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C398 &, C398, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C398 &, C398 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C398 &, C398 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C398 &, C398 const, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C398 &, C398 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C398 &, C398 const &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C398 &, C398 const &, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C398 &, C398 const &, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C398 const &, C398, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C398 const &, C398, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C398 const &, C398 const, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C398 const &, C398 const, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C398 const &, C398 &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C398 const &, C398 &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C398 const &, C398 &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C401, C401 const, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C401, C401 &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C401, C401 &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C401, C401 const &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C401, C401 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C401, C401 const &, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C401 const, C401, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C401 const, C401, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C401 const, C401 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C401 const, C401 const, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C401 const, C401 &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C401 const, C401 &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C401 const, C401 &, ret & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C401 const, C401 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C401 const, C401 const &, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C401 const, C401 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C401 const, C401 const &, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C401 &, C401, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C401 &, C401, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C401 &, C401 const, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C401 &, C401 &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C401 &, C401 const &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C401 const &, C401, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C401 const &, C401, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C401 const &, C401 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C401 const &, C401 const &, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C402, C402, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C402, C402 const, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C402, C402 &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C402, C402 &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C402, C402 const &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C402, C402 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C402, C402 const &, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C402 const, C402, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C402 const, C402, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C402 const, C402 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C402 const, C402 const, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C402 const, C402 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C402 const, C402 const, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C402 const, C402 &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C402 const, C402 &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C402 const, C402 &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C402 const, C402 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C402 const, C402 const &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C402 const, C402 const &, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C402 &, C402, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C402 &, C402, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C402 &, C402, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C402 &, C402 const, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C402 &, C402 const, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C402 &, C402 &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C402 &, C402 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C402 &, C402 const &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C402 &, C402 const &, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C402 const &, C402, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C402 const &, C402, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C402 const &, C402 const, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C402 const &, C402 &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C402 const &, C402 &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C402 const &, C402 const &, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C405, C405, void >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C405, C405, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C405, C405 const, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C405, C405 &, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C405, C405 const &, void >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C405, C405 const &, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C405 const, C405, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C405 const, C405, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C405 const, C405 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C405 const, C405 &, void >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C405 const, C405 &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C405 const, C405 &, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C405 const, C405 &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C405 const, C405 &, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C405 const, C405 const &, void >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C405 const, C405 const &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C405 const, C405 const &, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C405 const, C405 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C405 const, C405 const &, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C405 &, C405, void >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C405 &, C405, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C405 &, C405, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C405 &, C405, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C405 &, C405 const, void >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C405 &, C405 const, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C405 &, C405 &, void >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C405 &, C405 &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C405 &, C405 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C405 const &, C405, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C405 const &, C405, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C405 const &, C405, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C405 const &, C405 const, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C405 const &, C405 const, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C405 const &, C405 &, void >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C405 const &, C405 &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C405 const &, C405 &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C405 const &, C405 &, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C405 const &, C405 const &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C406, C406, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C406, C406, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C406, C406 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C406, C406 &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C406, C406 const &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C406, C406 const &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C406 const, C406, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C406 const, C406, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C406 const, C406 const, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C406 const, C406 const, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C406 const, C406 &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C406 const, C406 &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C406 const, C406 const &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C406 &, C406, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C406 &, C406, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C406 &, C406 const, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C406 &, C406 &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C406 &, C406 &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C406 &, C406 &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C406 const &, C406, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C406 const &, C406 const, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C406 const &, C406 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C407, C407, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C407, C407, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C407, C407, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C407, C407 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C407, C407 const, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C407, C407 &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C407, C407 &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C407, C407 &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C407, C407 &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C407, C407 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C407 const, C407, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C407 const, C407, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C407 const, C407, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C407 const, C407 const, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C407 const, C407 const, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C407 const, C407 &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C407 const, C407 &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C407 const, C407 const &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C407 const, C407 const &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C407 const, C407 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C407 const, C407 const &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C407 &, C407, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C407 &, C407, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C407 &, C407 &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C407 &, C407 &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C407 &, C407 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C407 &, C407 const &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C407 &, C407 const &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C407 &, C407 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C407 const &, C407, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C407 const &, C407, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C407 const &, C407, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C407 const &, C407 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C407 const &, C407 const, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C407 const &, C407 &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C407 const &, C407 &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C407 const &, C407 const &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C407 const &, C407 const &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C410, C410, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C410, C410 const, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C410, C410 &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C410, C410 &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C410, C410 &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C410, C410 const &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C410 const, C410, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C410 const, C410, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C410 const, C410 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C410 const, C410 &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C410 const, C410 &, ret & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C410 const, C410 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C410 const, C410 const &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C410 const, C410 const &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C410 &, C410, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C410 &, C410 const, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C410 &, C410 &, ret & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C410 &, C410 &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C410 &, C410 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C410 &, C410 const &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C410 const &, C410, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C410 const &, C410, ret & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C410 const &, C410 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C410 const &, C410 &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C410 const &, C410 &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C410 const &, C410 const &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C410 const &, C410 const &, ret & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C411, C411, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C411, C411 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C411, C411 &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C411, C411 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C411 const, C411, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C411 const, C411, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C411 const, C411 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C411 const, C411 const, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C411 const, C411 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C411 const, C411 &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C411 const, C411 &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C411 const, C411 const &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C411 &, C411, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C411 &, C411, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C411 &, C411, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C411 &, C411 const, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C411 &, C411 const, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C411 &, C411 &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C411 &, C411 &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C411 &, C411 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C411 const &, C411, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C411 const &, C411 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C411 const &, C411 const, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C411 const &, C411 &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C411 const &, C411 &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C411 const &, C411 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C411 const &, C411 const &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_plus< C411 const &, C411 const &, ret & >::value), 0); +TT_TEST_END diff --git a/libs/type_traits/test/has_binary_operators.hpp b/libs/type_traits/test/has_binary_operators.hpp new file mode 100644 index 0000000000..8d29df3c68 --- /dev/null +++ b/libs/type_traits/test/has_binary_operators.hpp @@ -0,0 +1,145 @@ +// (C) Copyright Frederic Bron 2009-2011. +// 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) + +#ifndef TT_HAS_BINARY_OPERATORS_HPP +#define TT_HAS_BINARY_OPERATORS_HPP + +// test with one template parameter +#define TEST_T(TYPE,RESULT) BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME<TYPE>::value), RESULT) +// test with one template parameter plus return value +#define TEST_TR(TYPE,RET,RESULT) BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME<TYPE,TYPE,RET>::value), RESULT) +// test with two template parameters +#define TEST_TT(TYPE1,TYPE2,RESULT) BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME<TYPE1,TYPE2>::value), RESULT) +// test with two template parameters plus return value +#define TEST_TTR(TYPE1,TYPE2,RET,RESULT) BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME<TYPE1,TYPE2,RET>::value), RESULT) + +namespace { + +struct without { }; + +struct ret { }; + +struct internal { ret operator BOOST_TT_TRAIT_OP (const internal&) const; }; + +struct external { }; +ret operator BOOST_TT_TRAIT_OP (const external&, const external&); + +struct comma1_ret { }; +struct ret_with_comma1 { comma1_ret operator,(int); }; + +struct internal_comma1 { ret_with_comma1 operator BOOST_TT_TRAIT_OP (const internal_comma1&) const; }; + +struct external_comma1 { }; +ret_with_comma1 operator BOOST_TT_TRAIT_OP (const external_comma1&, const external_comma1&); + +struct ret_with_comma2 { void operator,(int); }; + +struct internal_comma2 { ret_with_comma2 operator BOOST_TT_TRAIT_OP (const internal_comma2&) const; }; + +struct external_comma2 { }; +ret_with_comma2 operator BOOST_TT_TRAIT_OP (const external_comma2&, const external_comma2&); + +struct returns_int { int operator BOOST_TT_TRAIT_OP (const returns_int&); }; + +struct returns_void { void operator BOOST_TT_TRAIT_OP (const returns_void&); }; + +struct returns_void_star { void *operator BOOST_TT_TRAIT_OP (const returns_void_star&); }; + +struct returns_double { double operator BOOST_TT_TRAIT_OP (const returns_double&); }; + +struct ret1 { }; +struct convertible_to_ret1 { operator ret1 () const; }; +struct returns_convertible_to_ret1 { convertible_to_ret1 operator BOOST_TT_TRAIT_OP (const returns_convertible_to_ret1&); }; + +struct convertible_to_ret2 { }; +struct ret2 { ret2(const convertible_to_ret2); }; +struct returns_convertible_to_ret2 { convertible_to_ret2 operator BOOST_TT_TRAIT_OP (const returns_convertible_to_ret2&); }; + +class Base1 { }; +class Derived1 : public Base1 { }; + +bool operator BOOST_TT_TRAIT_OP (const Base1&, const Base1&) { return true; } + +class Base2 { }; +struct Derived2 : public Base2 { + Derived2(int); // to check if it works with a class that is not default constructible +}; + +bool operator BOOST_TT_TRAIT_OP (const Derived2&, const Derived2&) { return true; } + +struct tag { }; + +struct A { }; +struct B : public A { }; + +struct C { }; +struct D { }; +bool operator BOOST_TT_TRAIT_OP (const C&, void*) { return true; } +bool operator BOOST_TT_TRAIT_OP (void*, const D&) { return true; } +bool operator BOOST_TT_TRAIT_OP (const C&, const D&) { return true; } + +//class internal_private { ret operator BOOST_TT_TRAIT_OP (const internal_private&) const; }; + +void common() { + TEST_T(void, false); + TEST_TT(void, void, false); + TEST_TTR(void, void, void, false); + TEST_TTR(void, void, int, false); + + TEST_T(without, false); + TEST_T(internal, true); + TEST_T(external, true); + TEST_T(internal_comma1, true); + TEST_T(external_comma1, true); + TEST_T(internal_comma2, true); + TEST_T(external_comma2, true); + TEST_T(returns_int, true); + TEST_T(returns_void, true); + TEST_T(returns_void_star, true); + TEST_T(returns_double, true); + TEST_T(returns_convertible_to_ret1, true); + TEST_T(returns_convertible_to_ret2, true); + TEST_T(Base1, true); + TEST_T(Derived1, true); + TEST_T(Base2, false); + TEST_T(Derived2, true); + + TEST_TR(without, void, false); + TEST_TR(without, bool, false); + TEST_TR(internal, void, false); + TEST_TR(internal, bool, false); + TEST_TR(internal, ret, true); + TEST_TR(internal_comma1, void, false); + TEST_TR(internal_comma1, bool, false); + TEST_TR(internal_comma1, ret_with_comma1, true); + TEST_TR(internal_comma2, void, false); + TEST_TR(internal_comma2, bool, false); + TEST_TR(internal_comma2, ret_with_comma2, true); + TEST_TR(external, void, false); + TEST_TR(external, bool, false); + TEST_TR(external, ret, true); + TEST_TR(returns_int, void, false); + TEST_TR(returns_int, bool, true); + TEST_TR(returns_int, int, true); + TEST_TR(returns_void, void, true); + TEST_TR(returns_void, bool, false); + TEST_TR(returns_void_star, bool, true); + TEST_TR(returns_double, void, false); + TEST_TR(returns_double, bool, true); + TEST_TR(returns_double, double, true); + TEST_TR(returns_convertible_to_ret1, void, false); + TEST_TR(returns_convertible_to_ret1, ret1, true); + TEST_TR(returns_convertible_to_ret2, ret2, true); + TEST_TR(Base1, bool, true); + TEST_TR(Derived1, bool, true); + TEST_TR(Base2, bool, false); + TEST_TR(Derived2, bool, true); +// compile time error +// TEST_T(internal_private, false); +} + +} + +#endif diff --git a/libs/type_traits/test/has_bit_and_assign_test.cpp b/libs/type_traits/test/has_bit_and_assign_test.cpp new file mode 100644 index 0000000000..3be7994a52 --- /dev/null +++ b/libs/type_traits/test/has_bit_and_assign_test.cpp @@ -0,0 +1,228 @@ +// (C) Copyright 2009-2011 Frederic Bron. +// 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/has_bit_and_assign.hpp> +#endif + +#define BOOST_TT_TRAIT_NAME has_bit_and_assign +#define BOOST_TT_TRAIT_OP &= + + +#include "has_binary_operators.hpp" + +void specific() { + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, void, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, int &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, double, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, void* const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, void, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, void, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, void, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, bool, bool & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, bool &, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int const, bool & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, double &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, double const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* const &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* const &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, bool const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int const, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, double const, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, double &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, double const &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, double const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, void* const &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, void* const &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int* >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int* const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, bool, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int const, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int const &, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, void* &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, void* &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int*, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int* const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, bool, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, bool &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, double const, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, double const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void* const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void* &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void* &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void* const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void* const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool const, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool &, int & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, double &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, void* const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, void* const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int* & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int* const &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, bool &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, bool &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, bool const &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int const, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, double const, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, double & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, double &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, void* const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, void* &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int*, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int* &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int* &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, bool &, int & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, bool const &, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, bool const &, int & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, int &, int & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, double, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, double, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, double const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, double const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, void* &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, int* &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int const, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int const &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, double, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, double const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, void* const, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, void* &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, void* &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int* &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int* const &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, bool const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, double, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, double const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, void* const, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, void* const &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, bool &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, bool const &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, double, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, void*, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, void* &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int* const &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, bool, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, bool const &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, double, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, double const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, double &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, double &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, double const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, void* const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, int*, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, void*, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, void* const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, void* const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int* const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int* &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int* &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, bool, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, bool const, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int* const, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int* const &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, int const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, double const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, void* const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, void* const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, bool const &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int const, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, double, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, double, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, double const, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, double const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, void* const, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int* const, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int* const, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int* const &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int* const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, bool, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, bool const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, bool const, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, double const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, void* &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, void* const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, double const &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, void*, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int* const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int* &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int* &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int* const &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, bool, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, double const, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, double &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, double const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, void* >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, int* const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, int* &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, double &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, void* const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int*, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int* const &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, double const, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, void*, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, void* const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int*, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int* const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int* &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int* const &, int const & >::value), 0); + +} + +TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME) + common(); + specific(); +TT_TEST_END diff --git a/libs/type_traits/test/has_bit_and_test.cpp b/libs/type_traits/test/has_bit_and_test.cpp new file mode 100644 index 0000000000..4a2cfe6f9f --- /dev/null +++ b/libs/type_traits/test/has_bit_and_test.cpp @@ -0,0 +1,228 @@ +// (C) Copyright 2009-2011 Frederic Bron. +// 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/has_bit_and.hpp> +#endif + +#define BOOST_TT_TRAIT_NAME has_bit_and +#define BOOST_TT_TRAIT_OP & + + +#include "has_binary_operators.hpp" + +void specific() { + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, void, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, int &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, double, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, void* const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, void, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, void, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, void, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, bool, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, bool &, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, double &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, double const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* const &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* const &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, bool const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int const, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, double const, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, double &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, double const &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, double const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, void* const &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, void* const &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int* >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int* const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, bool, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int const, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int const &, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, void* &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, void* &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int*, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int* const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, bool, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, bool &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, double const, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, double const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void* const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void* &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void* &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void* const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void* const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool const, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, double &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, void* const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, void* const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int* & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int* const &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, bool &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, bool &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, bool const &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int const, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, double const, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, double & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, double &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, void* const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, void* &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int*, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int* &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int* &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, bool &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, bool const &, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, bool const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, int &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, double, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, double, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, double const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, double const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, void* &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, int* &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int const, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int const &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, double, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, double const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, void* const, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, void* &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, void* &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int* &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int* const &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, bool const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, double, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, double const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, void* const, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, void* const &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, bool &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, bool const &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, double, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, void*, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, void* &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int* const &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, bool, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, bool const &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, double, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, double const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, double &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, double &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, double const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, void* const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, int*, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, void*, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, void* const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, void* const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int* const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int* &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int* &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, bool, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, bool const, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int* const, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int* const &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, int const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, double const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, void* const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, void* const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, bool const &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int const, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, double, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, double, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, double const, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, double const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, void* const, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int* const, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int* const, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int* const &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int* const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, bool, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, bool const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, bool const, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, double const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, void* &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, void* const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, double const &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, void*, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int* const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int* &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int* &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int* const &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, bool, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, double const, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, double &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, double const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, void* >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, int* const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, int* &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, double &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, void* const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int*, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int* const &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, double const, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, void*, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, void* const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int*, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int* const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int* &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int* const &, int const & >::value), 0); + +} + +TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME) + common(); + specific(); +TT_TEST_END diff --git a/libs/type_traits/test/has_bit_or_assign_test.cpp b/libs/type_traits/test/has_bit_or_assign_test.cpp new file mode 100644 index 0000000000..ffacf904fb --- /dev/null +++ b/libs/type_traits/test/has_bit_or_assign_test.cpp @@ -0,0 +1,228 @@ +// (C) Copyright 2009-2011 Frederic Bron. +// 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/has_bit_or_assign.hpp> +#endif + +#define BOOST_TT_TRAIT_NAME has_bit_or_assign +#define BOOST_TT_TRAIT_OP |= + + +#include "has_binary_operators.hpp" + +void specific() { + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, void, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, int &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, double, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, void* const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, void, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, void, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, void, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, bool, bool & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, bool &, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int const, bool & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, double &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, double const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* const &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* const &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, bool const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int const, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, double const, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, double &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, double const &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, double const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, void* const &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, void* const &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int* >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int* const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, bool, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int const, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int const &, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, void* &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, void* &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int*, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int* const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, bool, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, bool &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, double const, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, double const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void* const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void* &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void* &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void* const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void* const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool const, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool &, int & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, double &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, void* const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, void* const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int* & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int* const &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, bool &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, bool &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, bool const &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int const, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, double const, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, double & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, double &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, void* const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, void* &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int*, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int* &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int* &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, bool &, int & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, bool const &, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, bool const &, int & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, int &, int & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, double, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, double, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, double const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, double const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, void* &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, int* &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int const, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int const &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, double, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, double const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, void* const, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, void* &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, void* &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int* &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int* const &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, bool const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, double, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, double const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, void* const, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, void* const &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, bool &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, bool const &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, double, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, void*, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, void* &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int* const &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, bool, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, bool const &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, double, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, double const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, double &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, double &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, double const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, void* const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, int*, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, void*, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, void* const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, void* const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int* const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int* &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int* &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, bool, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, bool const, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int* const, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int* const &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, int const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, double const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, void* const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, void* const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, bool const &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int const, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, double, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, double, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, double const, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, double const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, void* const, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int* const, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int* const, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int* const &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int* const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, bool, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, bool const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, bool const, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, double const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, void* &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, void* const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, double const &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, void*, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int* const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int* &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int* &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int* const &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, bool, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, double const, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, double &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, double const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, void* >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, int* const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, int* &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, double &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, void* const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int*, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int* const &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, double const, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, void*, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, void* const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int*, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int* const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int* &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int* const &, int const & >::value), 0); + +} + +TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME) + common(); + specific(); +TT_TEST_END diff --git a/libs/type_traits/test/has_bit_or_test.cpp b/libs/type_traits/test/has_bit_or_test.cpp new file mode 100644 index 0000000000..8418e11887 --- /dev/null +++ b/libs/type_traits/test/has_bit_or_test.cpp @@ -0,0 +1,228 @@ +// (C) Copyright 2009-2011 Frederic Bron. +// 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/has_bit_or.hpp> +#endif + +#define BOOST_TT_TRAIT_NAME has_bit_or +#define BOOST_TT_TRAIT_OP | + + +#include "has_binary_operators.hpp" + +void specific() { + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, void, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, int &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, double, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, void* const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, void, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, void, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, void, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, bool, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, bool &, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, double &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, double const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* const &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* const &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, bool const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int const, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, double const, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, double &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, double const &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, double const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, void* const &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, void* const &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int* >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int* const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, bool, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int const, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int const &, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, void* &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, void* &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int*, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int* const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, bool, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, bool &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, double const, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, double const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void* const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void* &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void* &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void* const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void* const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool const, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, double &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, void* const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, void* const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int* & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int* const &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, bool &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, bool &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, bool const &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int const, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, double const, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, double & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, double &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, void* const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, void* &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int*, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int* &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int* &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, bool &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, bool const &, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, bool const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, int &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, double, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, double, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, double const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, double const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, void* &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, int* &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int const, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int const &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, double, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, double const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, void* const, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, void* &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, void* &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int* &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int* const &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, bool const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, double, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, double const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, void* const, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, void* const &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, bool &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, bool const &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, double, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, void*, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, void* &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int* const &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, bool, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, bool const &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, double, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, double const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, double &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, double &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, double const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, void* const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, int*, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, void*, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, void* const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, void* const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int* const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int* &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int* &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, bool, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, bool const, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int* const, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int* const &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, int const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, double const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, void* const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, void* const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, bool const &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int const, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, double, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, double, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, double const, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, double const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, void* const, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int* const, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int* const, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int* const &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int* const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, bool, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, bool const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, bool const, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, double const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, void* &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, void* const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, double const &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, void*, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int* const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int* &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int* &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int* const &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, bool, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, double const, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, double &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, double const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, void* >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, int* const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, int* &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, double &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, void* const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int*, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int* const &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, double const, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, void*, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, void* const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int*, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int* const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int* &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int* const &, int const & >::value), 0); + +} + +TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME) + common(); + specific(); +TT_TEST_END diff --git a/libs/type_traits/test/has_bit_xor_assign_test.cpp b/libs/type_traits/test/has_bit_xor_assign_test.cpp new file mode 100644 index 0000000000..49301c53a2 --- /dev/null +++ b/libs/type_traits/test/has_bit_xor_assign_test.cpp @@ -0,0 +1,228 @@ +// (C) Copyright 2009-2011 Frederic Bron. +// 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/has_bit_xor_assign.hpp> +#endif + +#define BOOST_TT_TRAIT_NAME has_bit_xor_assign +#define BOOST_TT_TRAIT_OP ^= + + +#include "has_binary_operators.hpp" + +void specific() { + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, void, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, int &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, double, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, void* const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, void, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, void, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, void, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, bool, bool & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, bool &, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int const, bool & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, double &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, double const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* const &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* const &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, bool const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int const, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, double const, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, double &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, double const &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, double const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, void* const &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, void* const &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int* >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int* const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, bool, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int const, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int const &, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, void* &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, void* &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int*, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int* const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, bool, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, bool &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, double const, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, double const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void* const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void* &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void* &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void* const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void* const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool const, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool &, int & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, double &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, void* const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, void* const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int* & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int* const &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, bool &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, bool &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, bool const &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int const, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, double const, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, double & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, double &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, void* const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, void* &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int*, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int* &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int* &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, bool &, int & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, bool const &, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, bool const &, int & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, int &, int & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, double, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, double, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, double const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, double const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, void* &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, int* &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int const, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int const &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, double, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, double const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, void* const, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, void* &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, void* &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int* &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int* const &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, bool const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, double, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, double const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, void* const, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, void* const &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, bool &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, bool const &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, double, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, void*, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, void* &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int* const &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, bool, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, bool const &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, double, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, double const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, double &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, double &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, double const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, void* const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, int*, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, void*, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, void* const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, void* const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int* const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int* &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int* &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, bool, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, bool const, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int* const, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int* const &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, int const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, double const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, void* const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, void* const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, bool const &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int const, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, double, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, double, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, double const, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, double const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, void* const, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int* const, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int* const, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int* const &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int* const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, bool, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, bool const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, bool const, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, double const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, void* &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, void* const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, double const &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, void*, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int* const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int* &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int* &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int* const &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, bool, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, double const, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, double &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, double const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, void* >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, int* const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, int* &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, double &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, void* const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int*, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int* const &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, double const, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, void*, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, void* const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int*, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int* const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int* &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int* const &, int const & >::value), 0); + +} + +TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME) + common(); + specific(); +TT_TEST_END diff --git a/libs/type_traits/test/has_bit_xor_test.cpp b/libs/type_traits/test/has_bit_xor_test.cpp new file mode 100644 index 0000000000..659afc5305 --- /dev/null +++ b/libs/type_traits/test/has_bit_xor_test.cpp @@ -0,0 +1,228 @@ +// (C) Copyright 2009-2011 Frederic Bron. +// 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/has_bit_xor.hpp> +#endif + +#define BOOST_TT_TRAIT_NAME has_bit_xor +#define BOOST_TT_TRAIT_OP ^ + + +#include "has_binary_operators.hpp" + +void specific() { + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, void, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, int &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, double, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, void* const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, void, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, void, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, void, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, bool, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, bool &, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, double &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, double const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* const &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* const &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, bool const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int const, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, double const, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, double &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, double const &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, double const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, void* const &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, void* const &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int* >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int* const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, bool, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int const, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int const &, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, void* &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, void* &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int*, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int* const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, bool, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, bool &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, double const, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, double const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void* const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void* &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void* &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void* const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void* const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool const, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, double &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, void* const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, void* const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int* & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int* const &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, bool &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, bool &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, bool const &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int const, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, double const, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, double & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, double &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, void* const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, void* &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int*, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int* &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int* &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, bool &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, bool const &, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, bool const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, int &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, double, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, double, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, double const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, double const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, void* &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, int* &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int const, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int const &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, double, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, double const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, void* const, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, void* &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, void* &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int* &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int* const &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, bool const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, double, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, double const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, void* const, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, void* const &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, bool &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, bool const &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, double, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, void*, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, void* &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int* const &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, bool, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, bool const &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, double, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, double const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, double &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, double &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, double const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, void* const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, int*, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, void*, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, void* const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, void* const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int* const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int* &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int* &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, bool, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, bool const, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int* const, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int* const &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, int const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, double const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, void* const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, void* const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, bool const &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int const, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, double, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, double, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, double const, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, double const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, void* const, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int* const, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int* const, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int* const &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int* const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, bool, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, bool const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, bool const, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, double const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, void* &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, void* const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, double const &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, void*, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int* const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int* &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int* &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int* const &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, bool, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, double const, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, double &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, double const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, void* >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, int* const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, int* &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, double &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, void* const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int*, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int* const &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, double const, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, void*, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, void* const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int*, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int* const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int* &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int* const &, int const & >::value), 0); + +} + +TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME) + common(); + specific(); +TT_TEST_END diff --git a/libs/type_traits/test/has_complement_test.cpp b/libs/type_traits/test/has_complement_test.cpp new file mode 100644 index 0000000000..627f7c509a --- /dev/null +++ b/libs/type_traits/test/has_complement_test.cpp @@ -0,0 +1,228 @@ +// (C) Copyright 2009-2011 Frederic Bron. +// 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/has_complement.hpp> +#endif + +#define BOOST_TT_TRAIT_NAME has_complement +#define BOOST_TT_TRAIT_OP ~ + + +#include "has_prefix_operators.hpp" + +void specific() { + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int const & >::value), 0); + +} + +TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME) + common(); + specific(); +TT_TEST_END diff --git a/libs/type_traits/test/has_dereference_test.cpp b/libs/type_traits/test/has_dereference_test.cpp new file mode 100644 index 0000000000..52ca7808bd --- /dev/null +++ b/libs/type_traits/test/has_dereference_test.cpp @@ -0,0 +1,228 @@ +// (C) Copyright 2009-2011 Frederic Bron. +// 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/has_dereference.hpp> +#endif + +#define BOOST_TT_TRAIT_NAME has_dereference +#define BOOST_TT_TRAIT_OP * + + +#include "has_prefix_operators.hpp" + +void specific() { + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool*, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool*, bool & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool*, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool*, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool*, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool*, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool*, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool* const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool* const, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool* const, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool* const, bool & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool* const, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool* const, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool* & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool* &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool* &, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool* &, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool* &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool* &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool* const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool* const &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool* const &, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool* const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, int & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double* >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double*, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double*, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double*, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double*, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double* const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double* const, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double* const, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double* & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double* &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double* &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double* &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double* &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double* &, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double* &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double* &, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double* &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double* const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double* const &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double* const &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double* const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double* const &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double* const &, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double* const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double* const &, int const & >::value), 1); + +} + +TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME) + common(); + specific(); +TT_TEST_END diff --git a/libs/type_traits/test/has_divides_assign_test.cpp b/libs/type_traits/test/has_divides_assign_test.cpp new file mode 100644 index 0000000000..5b9565bd79 --- /dev/null +++ b/libs/type_traits/test/has_divides_assign_test.cpp @@ -0,0 +1,228 @@ +// (C) Copyright 2009-2011 Frederic Bron. +// 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/has_divides_assign.hpp> +#endif + +#define BOOST_TT_TRAIT_NAME has_divides_assign +#define BOOST_TT_TRAIT_OP /= + + +#include "has_binary_operators.hpp" + +void specific() { + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, void, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, int &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, double, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, void* const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, void, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, void, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, void, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, bool, bool & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, bool &, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int const, bool & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, double &, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, double const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* const &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* const &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, bool const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int const, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, double const, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, double &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, double const &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, double const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, void* const &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, void* const &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int* >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int* const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, bool, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int const, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int const &, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, void* &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, void* &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int*, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int* const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, bool, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, bool &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, double const, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, double const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void* const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void* &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void* &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void* const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void* const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool const, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool &, int & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, double &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, void* const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, void* const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int* & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int* const &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, bool &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, bool &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, bool const &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int const, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, double const, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, double & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, double &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, void* const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, void* &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int*, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int* &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int* &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, bool &, int & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, bool const &, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, bool const &, int & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, int &, int & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, double, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, double, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, double const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, double const, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, void* &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, int* &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int const, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int const &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, double, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, double const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, void* const, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, void* &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, void* &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int* &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int* const &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, bool const, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, double, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, double const, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, void* const, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, void* const &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, bool &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, bool const &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, double, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, void*, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, void* &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int* const &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, bool, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, bool const &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, double, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, double const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, double &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, double &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, double const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, void* const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, int*, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, void*, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, void* const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, void* const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int* const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int* &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int* &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, bool, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, bool const, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int* const, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int* const &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, int const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, double const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, void* const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, void* const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, bool const &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int const, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, double, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, double, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, double const, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, double const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, void* const, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int* const, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int* const, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int* const &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int* const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, bool, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, bool const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, bool const, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, double const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, void* &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, void* const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, double const &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, void*, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int* const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int* &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int* &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int* const &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, bool, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, double const, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, double &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, double const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, void* >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, int* const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, int* &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, double &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, void* const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int*, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int* const &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, double const, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, void*, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, void* const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int*, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int* const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int* &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int* const &, int const & >::value), 0); + +} + +TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME) + common(); + specific(); +TT_TEST_END diff --git a/libs/type_traits/test/has_divides_test.cpp b/libs/type_traits/test/has_divides_test.cpp new file mode 100644 index 0000000000..bdc129c42f --- /dev/null +++ b/libs/type_traits/test/has_divides_test.cpp @@ -0,0 +1,228 @@ +// (C) Copyright 2009-2011 Frederic Bron. +// 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/has_divides.hpp> +#endif + +#define BOOST_TT_TRAIT_NAME has_divides +#define BOOST_TT_TRAIT_OP / + + +#include "has_binary_operators.hpp" + +void specific() { + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, void, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, int &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, void, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, void, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, void, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, int* & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, void, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, bool, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, bool &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, double &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, void* &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int*, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int*, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int const &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, double, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, double &, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, void* &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int* const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int* &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int* const &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, bool, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, bool const &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, double const, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, double const &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, void*, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, void* const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, void* const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, void* const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int* const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int* const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, bool & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, bool const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, int &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, double const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, double &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, double const &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void* &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, int*, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, int* const &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, double & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, double &, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, double &, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, double &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, double const &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, void*, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, void* &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, void* &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, void* const &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, void* const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int*, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int* const, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, bool const, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, bool & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, double & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, void*, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, void*, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, void* &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, bool, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, bool &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, bool const &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, int const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, int &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, void*, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, void* const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, void* &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, double, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, double, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, double, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, double &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, double const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, void* const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, bool const, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, bool &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, bool &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, double const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int*, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int* const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, double &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, double &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, double &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, void*, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, void* &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, void* const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, void* const &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int*, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int* const, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int* const, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int* &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, bool &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, bool const &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, double &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, double const &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, void*, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, void* &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, int* const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, bool, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, bool, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int const, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, double &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, double &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int*, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int* & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int* &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int* &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, bool const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, bool const, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, bool &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, bool const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, double const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, double &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, void* &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int* const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int* const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, int &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, void* &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, int*, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, bool, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, bool const &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, bool const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, void* const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int*, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int* &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, bool const &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, double, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, double const &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, double const &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, void* const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, void* const, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, void* &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int*, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int* const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, bool &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int const, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, double const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, double const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, void* const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int* >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int*, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int*, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int*, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, bool const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, bool &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, double >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, double const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, int* &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, int* const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, bool, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, bool &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, double const &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, void* const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, void* &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int* const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool const &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, double &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, double &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, double const &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, void* &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int* >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int* const >::value), 0); + +} + +TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME) + common(); + specific(); +TT_TEST_END diff --git a/libs/type_traits/test/has_equal_to_test.cpp b/libs/type_traits/test/has_equal_to_test.cpp new file mode 100644 index 0000000000..65a0ff2635 --- /dev/null +++ b/libs/type_traits/test/has_equal_to_test.cpp @@ -0,0 +1,228 @@ +// (C) Copyright 2009-2011 Frederic Bron. +// 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/has_equal_to.hpp> +#endif + +#define BOOST_TT_TRAIT_NAME has_equal_to +#define BOOST_TT_TRAIT_OP == + + +#include "has_binary_operators.hpp" + +void specific() { + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, void, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, int &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, double, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, void* const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, void, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, void, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, void, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, bool, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, bool &, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, double &, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, double const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* const &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* const &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, bool const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int const, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, double const, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, double &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, double const &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, double const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, void* const &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, void* const &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int* >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int* const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, bool, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int const, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int const &, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, void* &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, void* &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int*, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int* const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, bool, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, bool &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, double const, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, double const, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void* const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void* &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void* &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void* const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void* const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool const, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, double &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, void* const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, void* const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int* & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int* const &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, bool &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, bool &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, bool const &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int const, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, double const, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, double & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, double &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, void* const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, void* &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int*, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int* &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int* &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, bool &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, bool const &, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, bool const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, int &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, double, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, double, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, double const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, double const, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, void* &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, int* &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int const, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int const &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, double, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, double const, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, void* const, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, void* &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, void* &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int* &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int* const &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, bool const, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, double, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, double const, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, void* const, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, void* const &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, bool &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, bool const &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, double, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, void*, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, void* &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int* const &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, bool, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, bool const &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, double, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, double const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, double &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, double &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, double const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, void* const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, int*, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, bool & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int &, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, void*, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, void* const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, void* const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int* const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int* &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int* &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, bool, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, bool const, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int* const, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int* const &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, int const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, double const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, void* const, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, void* const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, bool const &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int const, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, double, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, double, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, double const, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, double const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, void* const, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int* const, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int* const, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int* const &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int* const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, bool, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, bool const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, bool const, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, double const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, void* &, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, void* const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, double const &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, void*, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int* const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int* &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int* &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int* const &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, bool, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, double const, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, double &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, double const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, void* >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, int* const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, int* &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, double &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, void* const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int*, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int* const &, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, double const, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, void*, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, void* const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int*, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int* const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int* &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int* const &, int const & >::value), 1); + +} + +TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME) + common(); + specific(); +TT_TEST_END diff --git a/libs/type_traits/test/has_greater_equal_test.cpp b/libs/type_traits/test/has_greater_equal_test.cpp new file mode 100644 index 0000000000..f3d9d33791 --- /dev/null +++ b/libs/type_traits/test/has_greater_equal_test.cpp @@ -0,0 +1,228 @@ +// (C) Copyright 2009-2011 Frederic Bron. +// 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/has_greater_equal.hpp> +#endif + +#define BOOST_TT_TRAIT_NAME has_greater_equal +#define BOOST_TT_TRAIT_OP >= + + +#include "has_binary_operators.hpp" + +void specific() { + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, void, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, int &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, double, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, void* const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, void, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, void, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, void, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, bool, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, bool &, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, double &, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, double const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* const &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* const &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, bool const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int const, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, double const, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, double &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, double const &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, double const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, void* const &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, void* const &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int* >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int* const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, bool, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int const, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int const &, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, void* &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, void* &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int*, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int* const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, bool, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, bool &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, double const, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, double const, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void* const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void* &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void* &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void* const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void* const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool const, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, double &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, void* const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, void* const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int* & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int* const &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, bool &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, bool &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, bool const &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int const, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, double const, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, double & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, double &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, void* const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, void* &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int*, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int* &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int* &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, bool &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, bool const &, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, bool const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, int &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, double, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, double, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, double const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, double const, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, void* &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, int* &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int const, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int const &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, double, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, double const, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, void* const, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, void* &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, void* &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int* &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int* const &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, bool const, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, double, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, double const, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, void* const, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, void* const &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, bool &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, bool const &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, double, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, void*, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, void* &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int* const &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, bool, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, bool const &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, double, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, double const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, double &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, double &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, double const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, void* const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, int*, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, bool & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int &, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, void*, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, void* const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, void* const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int* const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int* &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int* &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, bool, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, bool const, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int* const, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int* const &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, int const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, double const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, void* const, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, void* const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, bool const &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int const, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, double, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, double, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, double const, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, double const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, void* const, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int* const, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int* const, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int* const &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int* const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, bool, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, bool const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, bool const, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, double const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, void* &, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, void* const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, double const &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, void*, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int* const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int* &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int* &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int* const &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, bool, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, double const, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, double &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, double const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, void* >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, int* const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, int* &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, double &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, void* const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int*, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int* const &, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, double const, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, void*, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, void* const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int*, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int* const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int* &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int* const &, int const & >::value), 1); + +} + +TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME) + common(); + specific(); +TT_TEST_END diff --git a/libs/type_traits/test/has_greater_test.cpp b/libs/type_traits/test/has_greater_test.cpp new file mode 100644 index 0000000000..3082765805 --- /dev/null +++ b/libs/type_traits/test/has_greater_test.cpp @@ -0,0 +1,228 @@ +// (C) Copyright 2009-2011 Frederic Bron. +// 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/has_greater.hpp> +#endif + +#define BOOST_TT_TRAIT_NAME has_greater +#define BOOST_TT_TRAIT_OP > + + +#include "has_binary_operators.hpp" + +void specific() { + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, void, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, int &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, double, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, void* const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, void, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, void, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, void, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, bool, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, bool &, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, double &, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, double const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* const &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* const &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, bool const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int const, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, double const, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, double &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, double const &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, double const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, void* const &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, void* const &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int* >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int* const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, bool, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int const, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int const &, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, void* &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, void* &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int*, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int* const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, bool, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, bool &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, double const, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, double const, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void* const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void* &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void* &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void* const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void* const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool const, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, double &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, void* const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, void* const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int* & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int* const &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, bool &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, bool &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, bool const &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int const, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, double const, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, double & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, double &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, void* const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, void* &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int*, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int* &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int* &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, bool &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, bool const &, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, bool const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, int &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, double, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, double, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, double const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, double const, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, void* &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, int* &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int const, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int const &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, double, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, double const, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, void* const, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, void* &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, void* &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int* &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int* const &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, bool const, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, double, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, double const, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, void* const, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, void* const &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, bool &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, bool const &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, double, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, void*, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, void* &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int* const &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, bool, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, bool const &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, double, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, double const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, double &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, double &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, double const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, void* const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, int*, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, bool & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int &, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, void*, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, void* const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, void* const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int* const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int* &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int* &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, bool, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, bool const, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int* const, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int* const &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, int const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, double const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, void* const, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, void* const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, bool const &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int const, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, double, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, double, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, double const, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, double const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, void* const, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int* const, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int* const, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int* const &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int* const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, bool, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, bool const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, bool const, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, double const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, void* &, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, void* const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, double const &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, void*, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int* const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int* &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int* &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int* const &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, bool, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, double const, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, double &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, double const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, void* >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, int* const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, int* &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, double &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, void* const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int*, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int* const &, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, double const, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, void*, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, void* const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int*, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int* const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int* &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int* const &, int const & >::value), 1); + +} + +TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME) + common(); + specific(); +TT_TEST_END diff --git a/libs/type_traits/test/has_left_shift_assign_test.cpp b/libs/type_traits/test/has_left_shift_assign_test.cpp new file mode 100644 index 0000000000..50de8292f4 --- /dev/null +++ b/libs/type_traits/test/has_left_shift_assign_test.cpp @@ -0,0 +1,228 @@ +// (C) Copyright 2009-2011 Frederic Bron. +// 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/has_left_shift_assign.hpp> +#endif + +#define BOOST_TT_TRAIT_NAME has_left_shift_assign +#define BOOST_TT_TRAIT_OP <<= + + +#include "has_binary_operators.hpp" + +void specific() { + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, void, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, int &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, double, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, void* const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, void, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, void, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, void, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, bool, bool & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, bool &, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int const, bool & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, double &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, double const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* const &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* const &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, bool const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int const, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, double const, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, double &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, double const &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, double const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, void* const &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, void* const &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int* >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int* const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, bool, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int const, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int const &, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, void* &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, void* &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int*, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int* const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, bool, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, bool &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, double const, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, double const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void* const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void* &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void* &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void* const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void* const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool const, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool &, int & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, double &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, void* const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, void* const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int* & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int* const &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, bool &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, bool &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, bool const &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int const, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, double const, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, double & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, double &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, void* const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, void* &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int*, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int* &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int* &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, bool &, int & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, bool const &, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, bool const &, int & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, int &, int & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, double, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, double, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, double const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, double const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, void* &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, int* &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int const, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int const &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, double, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, double const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, void* const, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, void* &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, void* &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int* &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int* const &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, bool const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, double, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, double const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, void* const, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, void* const &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, bool &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, bool const &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, double, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, void*, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, void* &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int* const &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, bool, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, bool const &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, double, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, double const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, double &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, double &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, double const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, void* const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, int*, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, void*, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, void* const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, void* const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int* const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int* &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int* &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, bool, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, bool const, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int* const, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int* const &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, int const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, double const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, void* const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, void* const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, bool const &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int const, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, double, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, double, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, double const, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, double const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, void* const, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int* const, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int* const, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int* const &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int* const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, bool, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, bool const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, bool const, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, double const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, void* &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, void* const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, double const &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, void*, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int* const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int* &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int* &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int* const &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, bool, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, double const, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, double &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, double const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, void* >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, int* const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, int* &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, double &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, void* const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int*, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int* const &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, double const, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, void*, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, void* const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int*, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int* const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int* &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int* const &, int const & >::value), 0); + +} + +TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME) + common(); + specific(); +TT_TEST_END diff --git a/libs/type_traits/test/has_left_shift_test.cpp b/libs/type_traits/test/has_left_shift_test.cpp new file mode 100644 index 0000000000..556267cd40 --- /dev/null +++ b/libs/type_traits/test/has_left_shift_test.cpp @@ -0,0 +1,250 @@ +// (C) Copyright 2009-2011 Frederic Bron. +// 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/has_left_shift.hpp> +#endif + +#define BOOST_TT_TRAIT_NAME has_left_shift +#define BOOST_TT_TRAIT_OP << + +#include <ostream> +#include <string> + +#include "has_binary_operators.hpp" + +void specific() { + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, void, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, int &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, double, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, void* const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, void, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, void, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, void, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, bool, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, bool &, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, double &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, double const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* const &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* const &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, bool const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int const, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, double const, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, double &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, double const &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, double const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, void* const &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, void* const &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int* >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int* const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, bool, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int const, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int const &, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, void* &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, void* &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int*, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int* const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, bool, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, bool &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, double const, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, double const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void* const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void* &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void* &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void* const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void* const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool const, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, double &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, void* const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, void* const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int* & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int* const &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, bool &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, bool &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, bool const &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int const, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, double const, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, double & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, double &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, void* const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, void* &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int*, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int* &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int* &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, bool &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, bool const &, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, bool const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, int &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, double, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, double, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, double const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, double const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, void* &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, int* &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int const, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int const &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, double, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, double const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, void* const, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, void* &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, void* &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int* &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int* const &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, bool const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, double, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, double const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, void* const, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, void* const &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, bool &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, bool const &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, double, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, void*, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, void* &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int* const &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, bool, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, bool const &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, double, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, double const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, double &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, double &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, double const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, void* const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, int*, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, void*, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, void* const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, void* const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int* const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int* &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int* &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, bool, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, bool const, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int* const, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int* const &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, int const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, double const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, void* const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, void* const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, bool const &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int const, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, double, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, double, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, double const, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, double const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, void* const, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int* const, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int* const, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int* const &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int* const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, bool, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, bool const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, bool const, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, double const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, void* &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, void* const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, double const &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, void*, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int* const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int* &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int* &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int* const &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, bool, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, double const, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, double &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, double const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, void* >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, int* const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, int* &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, double &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, void* const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int*, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int* const &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, double const, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, void*, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, void* const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int*, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int* const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int* &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int* const &, int const & >::value), 0); + + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< std::ostream, long, std::ostream& >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< std::ostream, unsigned long, std::ostream& >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< std::ostream, bool, std::ostream& >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< std::ostream, short, std::ostream& >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< std::ostream, unsigned short, std::ostream& >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< std::ostream, int, std::ostream& >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< std::ostream, unsigned int, std::ostream& >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< std::ostream, double, std::ostream& >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< std::ostream, float, std::ostream& >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< std::ostream, void*, std::ostream& >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< std::ostream, char, std::ostream& >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< std::ostream, signed char, std::ostream& >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< std::ostream, unsigned char, std::ostream& >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< std::ostream, const char*, std::ostream& >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< std::ostream, char*, std::ostream& >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< std::ostream, const signed char*, std::ostream& >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< std::ostream, signed char*, std::ostream& >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< std::ostream, const unsigned char*, std::ostream& >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< std::ostream, unsigned char*, std::ostream& >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< std::ostream, std::string, std::ostream& >::value), 1); +} + +TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME) + common(); + specific(); +TT_TEST_END diff --git a/libs/type_traits/test/has_less_equal_test.cpp b/libs/type_traits/test/has_less_equal_test.cpp new file mode 100644 index 0000000000..b5b8d5e8a3 --- /dev/null +++ b/libs/type_traits/test/has_less_equal_test.cpp @@ -0,0 +1,228 @@ +// (C) Copyright 2009-2011 Frederic Bron. +// 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/has_less_equal.hpp> +#endif + +#define BOOST_TT_TRAIT_NAME has_less_equal +#define BOOST_TT_TRAIT_OP <= + + +#include "has_binary_operators.hpp" + +void specific() { + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, void, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, int &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, double, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, void* const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, void, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, void, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, void, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, bool, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, bool &, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, double &, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, double const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* const &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* const &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, bool const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int const, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, double const, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, double &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, double const &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, double const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, void* const &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, void* const &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int* >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int* const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, bool, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int const, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int const &, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, void* &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, void* &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int*, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int* const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, bool, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, bool &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, double const, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, double const, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void* const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void* &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void* &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void* const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void* const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool const, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, double &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, void* const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, void* const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int* & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int* const &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, bool &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, bool &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, bool const &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int const, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, double const, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, double & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, double &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, void* const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, void* &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int*, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int* &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int* &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, bool &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, bool const &, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, bool const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, int &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, double, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, double, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, double const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, double const, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, void* &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, int* &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int const, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int const &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, double, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, double const, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, void* const, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, void* &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, void* &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int* &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int* const &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, bool const, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, double, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, double const, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, void* const, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, void* const &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, bool &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, bool const &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, double, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, void*, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, void* &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int* const &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, bool, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, bool const &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, double, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, double const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, double &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, double &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, double const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, void* const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, int*, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, bool & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int &, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, void*, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, void* const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, void* const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int* const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int* &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int* &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, bool, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, bool const, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int* const, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int* const &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, int const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, double const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, void* const, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, void* const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, bool const &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int const, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, double, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, double, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, double const, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, double const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, void* const, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int* const, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int* const, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int* const &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int* const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, bool, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, bool const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, bool const, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, double const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, void* &, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, void* const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, double const &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, void*, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int* const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int* &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int* &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int* const &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, bool, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, double const, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, double &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, double const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, void* >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, int* const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, int* &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, double &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, void* const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int*, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int* const &, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, double const, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, void*, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, void* const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int*, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int* const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int* &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int* const &, int const & >::value), 1); + +} + +TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME) + common(); + specific(); +TT_TEST_END diff --git a/libs/type_traits/test/has_less_test.cpp b/libs/type_traits/test/has_less_test.cpp new file mode 100644 index 0000000000..12ff5b73f9 --- /dev/null +++ b/libs/type_traits/test/has_less_test.cpp @@ -0,0 +1,228 @@ +// (C) Copyright 2009-2011 Frederic Bron. +// 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/has_less.hpp> +#endif + +#define BOOST_TT_TRAIT_NAME has_less +#define BOOST_TT_TRAIT_OP < + + +#include "has_binary_operators.hpp" + +void specific() { + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, void, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, int &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, double, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, void* const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, void, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, void, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, void, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, bool, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, bool &, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, double &, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, double const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* const &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* const &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, bool const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int const, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, double const, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, double &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, double const &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, double const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, void* const &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, void* const &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int* >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int* const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, bool, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int const, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int const &, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, void* &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, void* &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int*, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int* const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, bool, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, bool &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, double const, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, double const, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void* const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void* &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void* &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void* const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void* const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool const, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, double &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, void* const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, void* const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int* & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int* const &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, bool &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, bool &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, bool const &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int const, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, double const, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, double & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, double &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, void* const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, void* &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int*, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int* &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int* &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, bool &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, bool const &, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, bool const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, int &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, double, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, double, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, double const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, double const, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, void* &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, int* &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int const, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int const &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, double, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, double const, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, void* const, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, void* &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, void* &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int* &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int* const &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, bool const, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, double, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, double const, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, void* const, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, void* const &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, bool &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, bool const &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, double, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, void*, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, void* &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int* const &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, bool, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, bool const &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, double, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, double const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, double &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, double &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, double const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, void* const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, int*, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, bool & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int &, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, void*, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, void* const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, void* const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int* const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int* &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int* &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, bool, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, bool const, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int* const, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int* const &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, int const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, double const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, void* const, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, void* const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, bool const &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int const, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, double, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, double, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, double const, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, double const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, void* const, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int* const, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int* const, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int* const &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int* const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, bool, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, bool const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, bool const, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, double const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, void* &, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, void* const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, double const &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, void*, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int* const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int* &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int* &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int* const &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, bool, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, double const, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, double &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, double const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, void* >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, int* const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, int* &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, double &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, void* const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int*, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int* const &, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, double const, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, void*, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, void* const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int*, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int* const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int* &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int* const &, int const & >::value), 1); + +} + +TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME) + common(); + specific(); +TT_TEST_END diff --git a/libs/type_traits/test/has_logical_and_test.cpp b/libs/type_traits/test/has_logical_and_test.cpp new file mode 100644 index 0000000000..9c9eade517 --- /dev/null +++ b/libs/type_traits/test/has_logical_and_test.cpp @@ -0,0 +1,228 @@ +// (C) Copyright 2009-2011 Frederic Bron. +// 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/has_logical_and.hpp> +#endif + +#define BOOST_TT_TRAIT_NAME has_logical_and +#define BOOST_TT_TRAIT_OP && + + +#include "has_binary_operators.hpp" + +void specific() { + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, void, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, int &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, double, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, void* const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, void, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, void, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, void, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, bool, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, bool &, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, double &, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, double const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* &, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* &, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* const &, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* const &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, bool const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int const, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, double const, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, double &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, double const &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, double const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, void* const &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, void* const &, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int* >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int* const, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, bool, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int const, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int const &, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, void* &, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, void* &, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int*, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int* const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, bool, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, bool &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, double const, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, double const, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void* const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void* &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void* &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void* const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void* const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool const, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, double &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, void* const, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, void* const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int* & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int* const &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, bool &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, bool &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, bool const &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int const, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, double const, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, double & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, double &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, void* const, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, void* &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int*, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int* &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int* &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, bool &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, bool const &, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, bool const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, int &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, double, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, double, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, double const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, double const, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, void* &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, int* &, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int const, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int const &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, double, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, double const, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, void* const, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, void* &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, void* &, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int* &, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int* const &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, bool const, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, double, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, double const, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, void* const, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, void* const &, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, bool &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, bool const &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, double, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, void*, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, void* &, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int* const &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, bool, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, bool const &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, double, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, double const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, double &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, double &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, double const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, void* const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, int*, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, bool & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int &, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, void*, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, void* const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, void* const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int* const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int* &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int* &, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, bool, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, bool const, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int const, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int* const, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int* const &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, int const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, double const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, void* const, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, void* const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, bool const &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int const, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int const, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, double, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, double, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, double const, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, double const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, void* const, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int* const, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int* const, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int* const &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int* const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, bool, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, bool const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, bool const, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int const, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, double const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, void* &, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, void* const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int const, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, double const &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, void*, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int* const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int* &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int* &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int* const &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, bool, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, double const, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, double &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, double const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, void* >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, int* const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, int* &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, double &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, void* const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int*, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int* const &, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, double const, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, void*, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, void* const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int*, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int* const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int* &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int* const &, int const & >::value), 1); + +} + +TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME) + common(); + specific(); +TT_TEST_END diff --git a/libs/type_traits/test/has_logical_not_test.cpp b/libs/type_traits/test/has_logical_not_test.cpp new file mode 100644 index 0000000000..fdb467b964 --- /dev/null +++ b/libs/type_traits/test/has_logical_not_test.cpp @@ -0,0 +1,231 @@ +// (C) Copyright 2009-2011 Frederic Bron. +// 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/has_logical_not.hpp> +#endif + +#define BOOST_TT_TRAIT_NAME has_logical_not +#define BOOST_TT_TRAIT_OP ! + +#include <iostream> + +#include "has_prefix_operators.hpp" + +void specific() { + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int const & >::value), 1); + + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< std::ostream, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< std::istream, bool >::value), 1); +} + +TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME) + common(); + specific(); +TT_TEST_END diff --git a/libs/type_traits/test/has_logical_or_test.cpp b/libs/type_traits/test/has_logical_or_test.cpp new file mode 100644 index 0000000000..ff9b1031a3 --- /dev/null +++ b/libs/type_traits/test/has_logical_or_test.cpp @@ -0,0 +1,228 @@ +// (C) Copyright 2009-2011 Frederic Bron. +// 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/has_logical_or.hpp> +#endif + +#define BOOST_TT_TRAIT_NAME has_logical_or +#define BOOST_TT_TRAIT_OP || + + +#include "has_binary_operators.hpp" + +void specific() { + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, void, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, int &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, double, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, void* const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, void, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, void, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, void, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, bool, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, bool &, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, double &, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, double const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* &, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* &, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* const &, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* const &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, bool const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int const, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, double const, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, double &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, double const &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, double const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, void* const &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, void* const &, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int* >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int* const, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, bool, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int const, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int const &, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, void* &, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, void* &, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int*, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int* const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, bool, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, bool &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, double const, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, double const, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void* const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void* &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void* &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void* const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void* const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool const, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, double &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, void* const, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, void* const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int* & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int* const &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, bool &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, bool &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, bool const &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int const, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, double const, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, double & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, double &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, void* const, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, void* &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int*, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int* &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int* &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, bool &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, bool const &, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, bool const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, int &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, double, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, double, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, double const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, double const, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, void* &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, int* &, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int const, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int const &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, double, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, double const, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, void* const, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, void* &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, void* &, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int* &, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int* const &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, bool const, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, double, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, double const, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, void* const, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, void* const &, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, bool &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, bool const &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, double, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, void*, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, void* &, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int* const &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, bool, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, bool const &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, double, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, double const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, double &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, double &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, double const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, void* const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, int*, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, bool & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int &, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, void*, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, void* const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, void* const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int* const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int* &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int* &, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, bool, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, bool const, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int const, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int* const, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int* const &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, int const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, double const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, void* const, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, void* const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, bool const &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int const, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int const, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, double, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, double, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, double const, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, double const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, void* const, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int* const, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int* const, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int* const &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int* const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, bool, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, bool const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, bool const, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int const, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, double const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, void* &, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, void* const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int const, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, double const &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, void*, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int* const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int* &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int* &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int* const &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, bool, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, double const, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, double &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, double const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, void* >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, int* const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, int* &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, double &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, void* const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int*, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int* const &, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, double const, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, void*, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, void* const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int*, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int* const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int* &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int* const &, int const & >::value), 1); + +} + +TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME) + common(); + specific(); +TT_TEST_END diff --git a/libs/type_traits/test/has_minus_assign_test.cpp b/libs/type_traits/test/has_minus_assign_test.cpp new file mode 100644 index 0000000000..a758d2d729 --- /dev/null +++ b/libs/type_traits/test/has_minus_assign_test.cpp @@ -0,0 +1,228 @@ +// (C) Copyright 2009-2011 Frederic Bron. +// 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/has_minus_assign.hpp> +#endif + +#define BOOST_TT_TRAIT_NAME has_minus_assign +#define BOOST_TT_TRAIT_OP -= + + +#include "has_binary_operators.hpp" + +void specific() { + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, void, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, int &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, void, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, void, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, void, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, int* & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, void, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, bool, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, bool &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, double &, bool & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, void* &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int*, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int*, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int const &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, double, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, double &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, void* &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int* const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int* &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int* const &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, bool, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, bool const &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, double const, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, double const &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, void*, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, void* const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, void* const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, void* const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int* const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int* const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, bool const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, int &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, double const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, double &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, double const &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void* &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, int*, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, int* const &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int, int & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int const, int & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, double & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, double &, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, double &, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, double &, int & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, double const &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, void*, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, void* &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, void* &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, void* const &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, void* const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int*, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int* const, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, bool const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, double & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, void*, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, void*, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, void* &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, bool, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, bool &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, bool const &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, int const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, int &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, void*, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, void* const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, void* &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, double, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, double, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, double, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, double &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, double const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, void* const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, bool const, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, bool &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, bool &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, double const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int*, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int* const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, double &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, double &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, double &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, void*, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, void* &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, void* const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, void* const &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int*, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int* const, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int* const, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int* &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, bool &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, bool const &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, double &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, double const &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, void*, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, void* &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, int* const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, bool, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, bool, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int const, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, double &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, double &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int*, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int* & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int* &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int* &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, bool const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, bool const, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, bool &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, bool const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, double const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, double &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, void* &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int* const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int* const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, int &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, void* &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, int*, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, bool, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, bool const &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, bool const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, void* const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int*, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int* &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, bool const &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, double, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, double const &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, double const &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, void* const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, void* const, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, void* &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int*, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int* const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, bool &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int const, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, double const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, double const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, void* const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int* >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int*, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int*, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int*, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, bool const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, bool &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, double >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, double const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, int* &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, int* const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, bool, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, bool &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, double const &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, void* const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, void* &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int* const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool const &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, double &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, double &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, double const &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, void* &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int* >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int* const >::value), 0); + +} + +TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME) + common(); + specific(); +TT_TEST_END diff --git a/libs/type_traits/test/has_minus_test.cpp b/libs/type_traits/test/has_minus_test.cpp new file mode 100644 index 0000000000..01772f75ef --- /dev/null +++ b/libs/type_traits/test/has_minus_test.cpp @@ -0,0 +1,228 @@ +// (C) Copyright 2009-2011 Frederic Bron. +// 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/has_minus.hpp> +#endif + +#define BOOST_TT_TRAIT_NAME has_minus +#define BOOST_TT_TRAIT_OP - + + +#include "has_binary_operators.hpp" + +void specific() { + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, void, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, int &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, void, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, void, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, void, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, int* & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, void, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, bool, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, bool &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, double &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, void* &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int*, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int*, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int const &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, double, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, double &, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, void* &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int* const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int* &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int* const &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, bool, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, bool const &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, double const, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, double const &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, void*, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, void* const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, void* const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, void* const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int* const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int* const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, bool & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, bool const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, int &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, double const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, double &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, double const &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void* &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, int*, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, int* const &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, double & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, double &, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, double &, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, double &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, double const &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, void*, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, void* &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, void* &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, void* const &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, void* const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int*, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int* const, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, bool const, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, bool & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, double & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, void*, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, void*, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, void* &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, bool, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, bool &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, bool const &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, int const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, int &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, void*, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, void* const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, void* &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, double, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, double, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, double, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, double &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, double const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, void* const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, bool const, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, bool &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, bool &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, double const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int*, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int* const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, double &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, double &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, double &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, void*, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, void* &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, void* const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, void* const &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int*, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int* const, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int* const, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int* &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, bool &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, bool const &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, double &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, double const &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, void*, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, void* &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, int* const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, bool, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, bool, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int const, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, double &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, double &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int*, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int* & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int* &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int* &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, bool const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, bool const, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, bool &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, bool const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, double const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, double &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, void* &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int* const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int* const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, int &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, void* &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, int*, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, bool, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, bool const &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, bool const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, void* const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int*, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int* &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, bool const &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, double, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, double const &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, double const &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, void* const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, void* const, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, void* &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int*, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int* const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, bool &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int const, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, double const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, double const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, void* const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int* >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int*, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int*, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int*, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, bool const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, bool &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, double >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, double const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, int* &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, int* const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, bool, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, bool &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, double const &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, void* const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, void* &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int* const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool const &, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int const, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, double &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, double &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, double const &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, void* &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int* >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int* const >::value), 1); + +} + +TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME) + common(); + specific(); +TT_TEST_END diff --git a/libs/type_traits/test/has_modulus_assign_test.cpp b/libs/type_traits/test/has_modulus_assign_test.cpp new file mode 100644 index 0000000000..bf962002e9 --- /dev/null +++ b/libs/type_traits/test/has_modulus_assign_test.cpp @@ -0,0 +1,228 @@ +// (C) Copyright 2009-2011 Frederic Bron. +// 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/has_modulus_assign.hpp> +#endif + +#define BOOST_TT_TRAIT_NAME has_modulus_assign +#define BOOST_TT_TRAIT_OP %= + + +#include "has_binary_operators.hpp" + +void specific() { + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, void, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, int &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, double, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, void* const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, void, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, void, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, void, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, bool, bool & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, bool &, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int const, bool & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, double &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, double const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* const &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* const &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, bool const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int const, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, double const, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, double &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, double const &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, double const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, void* const &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, void* const &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int* >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int* const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, bool, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int const, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int const &, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, void* &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, void* &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int*, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int* const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, bool, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, bool &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, double const, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, double const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void* const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void* &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void* &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void* const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void* const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool const, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool &, int & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, double &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, void* const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, void* const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int* & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int* const &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, bool &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, bool &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, bool const &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int const, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, double const, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, double & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, double &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, void* const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, void* &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int*, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int* &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int* &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, bool &, int & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, bool const &, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, bool const &, int & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, int &, int & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, double, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, double, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, double const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, double const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, void* &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, int* &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int const, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int const &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, double, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, double const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, void* const, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, void* &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, void* &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int* &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int* const &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, bool const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, double, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, double const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, void* const, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, void* const &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, bool &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, bool const &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, double, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, void*, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, void* &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int* const &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, bool, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, bool const &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, double, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, double const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, double &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, double &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, double const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, void* const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, int*, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, void*, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, void* const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, void* const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int* const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int* &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int* &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, bool, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, bool const, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int* const, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int* const &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, int const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, double const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, void* const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, void* const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, bool const &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int const, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, double, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, double, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, double const, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, double const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, void* const, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int* const, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int* const, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int* const &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int* const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, bool, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, bool const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, bool const, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, double const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, void* &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, void* const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, double const &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, void*, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int* const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int* &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int* &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int* const &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, bool, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, double const, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, double &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, double const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, void* >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, int* const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, int* &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, double &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, void* const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int*, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int* const &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, double const, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, void*, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, void* const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int*, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int* const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int* &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int* const &, int const & >::value), 0); + +} + +TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME) + common(); + specific(); +TT_TEST_END diff --git a/libs/type_traits/test/has_modulus_test.cpp b/libs/type_traits/test/has_modulus_test.cpp new file mode 100644 index 0000000000..ab697ea047 --- /dev/null +++ b/libs/type_traits/test/has_modulus_test.cpp @@ -0,0 +1,228 @@ +// (C) Copyright 2009-2011 Frederic Bron. +// 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/has_modulus.hpp> +#endif + +#define BOOST_TT_TRAIT_NAME has_modulus +#define BOOST_TT_TRAIT_OP % + + +#include "has_binary_operators.hpp" + +void specific() { + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, void, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, int &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, void, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, void, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, void, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, int* & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, void, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, bool, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, bool &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, double &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, void* &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int*, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int*, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int const &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, double, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, double &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, void* &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int* const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int* &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int* const &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, bool, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, bool const &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, double const, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, double const &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, void*, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, void* const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, void* const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, void* const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int* const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int* const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, bool & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, bool const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, int &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, double const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, double &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, double const &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void* &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, int*, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, int* const &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, double & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, double &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, double &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, double &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, double const &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, void*, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, void* &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, void* &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, void* const &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, void* const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int*, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int* const, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, bool const, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, bool & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, double & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, void*, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, void*, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, void* &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, bool, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, bool &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, bool const &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, int const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, int &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, void*, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, void* const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, void* &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, double, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, double, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, double, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, double &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, double const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, void* const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, bool const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, bool &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, bool &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, double const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int*, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int* const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, double &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, double &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, double &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, void*, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, void* &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, void* const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, void* const &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int*, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int* const, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int* const, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int* &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, bool &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, bool const &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, double &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, double const &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, void*, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, void* &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, int* const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, bool, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, bool, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int const, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, double &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, double &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int*, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int* & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int* &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int* &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, bool const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, bool const, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, bool &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, bool const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, double const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, double &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, void* &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int* const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int* const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, int &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, void* &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, int*, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, bool, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, bool const &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, bool const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, void* const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int*, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int* &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, bool const &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, double, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, double const &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, double const &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, void* const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, void* const, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, void* &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int*, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int* const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, bool &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int const, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, double const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, double const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, void* const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int* >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int*, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int*, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int*, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, bool const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, bool &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, double >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, double const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, int* &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, int* const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, bool, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, bool &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, double const &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, void* const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, void* &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int* const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool const &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, double &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, double &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, double const &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, void* &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int* >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int* const >::value), 0); + +} + +TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME) + common(); + specific(); +TT_TEST_END diff --git a/libs/type_traits/test/has_multiplies_assign_test.cpp b/libs/type_traits/test/has_multiplies_assign_test.cpp new file mode 100644 index 0000000000..852ec01bcb --- /dev/null +++ b/libs/type_traits/test/has_multiplies_assign_test.cpp @@ -0,0 +1,228 @@ +// (C) Copyright 2009-2011 Frederic Bron. +// 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/has_multiplies_assign.hpp> +#endif + +#define BOOST_TT_TRAIT_NAME has_multiplies_assign +#define BOOST_TT_TRAIT_OP *= + + +#include "has_binary_operators.hpp" + +void specific() { + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, void, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, int &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, void, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, void, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, void, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, int* & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, void, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, bool, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, bool &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, double &, bool & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, void* &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int*, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int*, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int const &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, double, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, double &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, void* &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int* const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int* &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int* const &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, bool, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, bool const &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, double const, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, double const &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, void*, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, void* const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, void* const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, void* const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int* const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int* const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, bool const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, int &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, double const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, double &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, double const &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void* &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, int*, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, int* const &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int, int & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int const, int & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, double & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, double &, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, double &, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, double &, int & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, double const &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, void*, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, void* &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, void* &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, void* const &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, void* const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int*, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int* const, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, bool const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, double & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, void*, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, void*, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, void* &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, bool, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, bool &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, bool const &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, int const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, int &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, void*, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, void* const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, void* &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, double, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, double, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, double, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, double &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, double const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, void* const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, bool const, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, bool &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, bool &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, double const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int*, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int* const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, double &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, double &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, double &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, void*, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, void* &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, void* const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, void* const &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int*, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int* const, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int* const, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int* &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, bool &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, bool const &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, double &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, double const &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, void*, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, void* &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, int* const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, bool, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, bool, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int const, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, double &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, double &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int*, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int* & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int* &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int* &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, bool const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, bool const, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, bool &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, bool const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, double const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, double &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, void* &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int* const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int* const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, int &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, void* &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, int*, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, bool, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, bool const &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, bool const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, void* const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int*, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int* &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, bool const &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, double, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, double const &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, double const &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, void* const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, void* const, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, void* &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int*, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int* const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, bool &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int const, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, double const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, double const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, void* const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int* >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int*, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int*, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int*, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, bool const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, bool &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, double >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, double const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, int* &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, int* const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, bool, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, bool &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, double const &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, void* const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, void* &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int* const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool const &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, double &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, double &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, double const &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, void* &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int* >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int* const >::value), 0); + +} + +TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME) + common(); + specific(); +TT_TEST_END diff --git a/libs/type_traits/test/has_multiplies_test.cpp b/libs/type_traits/test/has_multiplies_test.cpp new file mode 100644 index 0000000000..89316ad1ac --- /dev/null +++ b/libs/type_traits/test/has_multiplies_test.cpp @@ -0,0 +1,228 @@ +// (C) Copyright 2009-2011 Frederic Bron. +// 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/has_multiplies.hpp> +#endif + +#define BOOST_TT_TRAIT_NAME has_multiplies +#define BOOST_TT_TRAIT_OP * + + +#include "has_binary_operators.hpp" + +void specific() { + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, void, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, int &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, void, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, void, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, void, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, int* & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, void, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, bool, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, bool &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, double &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, void* &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int*, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int*, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int const &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, double, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, double &, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, void* &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int* const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int* &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int* const &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, bool, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, bool const &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, double const, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, double const &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, void*, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, void* const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, void* const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, void* const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int* const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int* const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, bool & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, bool const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, int &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, double const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, double &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, double const &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void* &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, int*, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, int* const &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, double & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, double &, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, double &, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, double &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, double const &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, void*, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, void* &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, void* &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, void* const &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, void* const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int*, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int* const, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, bool const, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, bool & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, double & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, void*, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, void*, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, void* &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, bool, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, bool &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, bool const &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, int const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, int &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, void*, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, void* const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, void* &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, double, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, double, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, double, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, double &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, double const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, void* const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, bool const, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, bool &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, bool &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, double const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int*, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int* const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, double &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, double &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, double &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, void*, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, void* &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, void* const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, void* const &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int*, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int* const, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int* const, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int* &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, bool &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, bool const &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, double &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, double const &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, void*, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, void* &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, int* const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, bool, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, bool, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int const, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, double &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, double &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int*, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int* & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int* &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int* &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, bool const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, bool const, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, bool &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, bool const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, double const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, double &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, void* &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int* const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int* const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, int &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, void* &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, int*, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, bool, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, bool const &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, bool const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, void* const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int*, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int* &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, bool const &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, double, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, double const &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, double const &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, void* const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, void* const, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, void* &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int*, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int* const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, bool &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int const, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, double const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, double const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, void* const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int* >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int*, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int*, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int*, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, bool const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, bool &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, double >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, double const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, int* &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, int* const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, bool, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, bool &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, double const &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, void* const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, void* &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int* const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool const &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, double &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, double &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, double const &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, void* &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int* >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int* const >::value), 0); + +} + +TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME) + common(); + specific(); +TT_TEST_END diff --git a/libs/type_traits/test/has_negate_test.cpp b/libs/type_traits/test/has_negate_test.cpp new file mode 100644 index 0000000000..baa0e88a03 --- /dev/null +++ b/libs/type_traits/test/has_negate_test.cpp @@ -0,0 +1,228 @@ +// (C) Copyright 2009-2011 Frederic Bron. +// 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/has_negate.hpp> +#endif + +#define BOOST_TT_TRAIT_NAME has_negate +#define BOOST_TT_TRAIT_OP - + + +#include "has_prefix_operators.hpp" + +void specific() { + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int const & >::value), 0); + +} + +TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME) + common(); + specific(); +TT_TEST_END diff --git a/libs/type_traits/test/has_not_equal_to_test.cpp b/libs/type_traits/test/has_not_equal_to_test.cpp new file mode 100644 index 0000000000..17462ab7c6 --- /dev/null +++ b/libs/type_traits/test/has_not_equal_to_test.cpp @@ -0,0 +1,228 @@ +// (C) Copyright 2009-2011 Frederic Bron. +// 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/has_not_equal_to.hpp> +#endif + +#define BOOST_TT_TRAIT_NAME has_not_equal_to +#define BOOST_TT_TRAIT_OP != + + +#include "has_binary_operators.hpp" + +void specific() { + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, void, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, int &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, double, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, void* const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, void, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, void, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, void, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, bool, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, bool &, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, double &, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, double const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* const &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* const &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, bool const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int const, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, double const, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, double &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, double const &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, double const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, void* const &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, void* const &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int* >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int* const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, bool, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int const, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int const &, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, void* &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, void* &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int*, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int* const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, bool, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, bool &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, double const, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, double const, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void* const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void* &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void* &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void* const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void* const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool const, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, double &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, void* const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, void* const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int* & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int* const &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, bool &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, bool &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, bool const &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int const, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, double const, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, double & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, double &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, void* const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, void* &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int*, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int* &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int* &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, bool &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, bool const &, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, bool const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, int &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, double, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, double, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, double const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, double const, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, void* &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, int* &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int const, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int const &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, double, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, double const, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, void* const, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, void* &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, void* &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int* &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int* const &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, bool const, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, double, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, double const, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, void* const, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, void* const &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, bool &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, bool const &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, double, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, void*, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, void* &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int* const &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, bool, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, bool const &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, double, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, double const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, double &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, double &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, double const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, void* const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, int*, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, bool & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int &, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, void*, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, void* const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, void* const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int* const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int* &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int* &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, bool, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, bool const, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int* const, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int* const &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, int const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, double const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, void* const, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, void* const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, bool const &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int const, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, double, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, double, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, double const, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, double const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, void* const, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int* const, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int* const, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int* const &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int* const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, bool, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, bool const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, bool const, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, double const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, void* &, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, void* const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, double const &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, void*, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int* const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int* &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int* &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int* const &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, bool, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, double const, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, double &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, double const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, void* >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, int* const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, int* &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, double &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, void* const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int*, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int* const &, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, double const, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, void*, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, void* const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int*, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int* const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int* &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int* const &, int const & >::value), 1); + +} + +TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME) + common(); + specific(); +TT_TEST_END diff --git a/libs/type_traits/test/has_nothrow_assign_test.cpp b/libs/type_traits/test/has_nothrow_assign_test.cpp new file mode 100644 index 0000000000..1bcf3ac7da --- /dev/null +++ b/libs/type_traits/test/has_nothrow_assign_test.cpp @@ -0,0 +1,211 @@ + +// (C) Copyright John Maddock 2000. +// 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/has_nothrow_assign.hpp> +#endif + +TT_TEST_BEGIN(has_nothrow_assign) + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_assign<bool>::value, true); +#ifndef TEST_STD +// unspecified behaviour: +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_assign<bool const>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_assign<bool volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_assign<bool const volatile>::value, false); +#endif + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_assign<signed char>::value, true); +#ifndef TEST_STD +// unspecified behaviour: +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_assign<signed char const>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_assign<signed char volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_assign<signed char const volatile>::value, false); +#endif +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_assign<unsigned char>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_assign<char>::value, true); +#ifndef TEST_STD +// unspecified behaviour: +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_assign<unsigned char const>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_assign<char const>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_assign<unsigned char volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_assign<char volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_assign<unsigned char const volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_assign<char const volatile>::value, false); +#endif + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_assign<unsigned short>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_assign<short>::value, true); +#ifndef TEST_STD +// unspecified behaviour: +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_assign<unsigned short const>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_assign<short const>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_assign<unsigned short volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_assign<short volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_assign<unsigned short const volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_assign<short const volatile>::value, false); +#endif + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_assign<unsigned int>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_assign<int>::value, true); +#ifndef TEST_STD +// unspecified behaviour: +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_assign<unsigned int const>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_assign<int const>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_assign<unsigned int volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_assign<int volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_assign<unsigned int const volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_assign<int const volatile>::value, false); +#endif + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_assign<unsigned long>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_assign<long>::value, true); +#ifndef TEST_STD +// unspecified behaviour: +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_assign<unsigned long const>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_assign<long const>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_assign<unsigned long volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_assign<long volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_assign<unsigned long const volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_assign<long const volatile>::value, false); +#endif + +#ifdef BOOST_HAS_LONG_LONG + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_assign< ::boost::ulong_long_type>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_assign< ::boost::long_long_type>::value, true); +#ifndef TEST_STD +// unspecified behaviour: +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_assign< ::boost::ulong_long_type const>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_assign< ::boost::long_long_type const>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_assign< ::boost::ulong_long_type volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_assign< ::boost::long_long_type volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_assign< ::boost::ulong_long_type const volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_assign< ::boost::long_long_type const volatile>::value, false); +#endif +#endif + +#ifdef BOOST_HAS_MS_INT64 + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_assign<unsigned __int8>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_assign<__int8>::value, true); +#ifndef TEST_STD +// unspecified behaviour: +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_assign<unsigned __int8 const>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_assign<__int8 const>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_assign<unsigned __int8 volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_assign<__int8 volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_assign<unsigned __int8 const volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_assign<__int8 const volatile>::value, false); +#endif + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_assign<unsigned __int16>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_assign<__int16>::value, true); +#ifndef TEST_STD +// unspecified behaviour: +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_assign<unsigned __int16 const>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_assign<__int16 const>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_assign<unsigned __int16 volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_assign<__int16 volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_assign<unsigned __int16 const volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_assign<__int16 const volatile>::value, false); +#endif + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_assign<unsigned __int32>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_assign<__int32>::value, true); +#ifndef TEST_STD +// unspecified behaviour: +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_assign<unsigned __int32 const>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_assign<__int32 const>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_assign<unsigned __int32 volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_assign<__int32 volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_assign<unsigned __int32 const volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_assign<__int32 const volatile>::value, false); +#endif + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_assign<unsigned __int64>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_assign<__int64>::value, true); +#ifndef TEST_STD +// unspecified behaviour: +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_assign<unsigned __int64 const>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_assign<__int64 const>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_assign<unsigned __int64 volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_assign<__int64 volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_assign<unsigned __int64 const volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_assign<__int64 const volatile>::value, false); +#endif +#endif + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_assign<float>::value, true); +#ifndef TEST_STD +// unspecified behaviour: +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_assign<float const>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_assign<float volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_assign<float const volatile>::value, false); +#endif + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_assign<double>::value, true); +#ifndef TEST_STD +// unspecified behaviour: +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_assign<double const>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_assign<double volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_assign<double const volatile>::value, false); +#endif + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_assign<long double>::value, true); +#ifndef TEST_STD +// unspecified behaviour: +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_assign<long double const>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_assign<long double volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_assign<long double const volatile>::value, false); +#endif + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_assign<int>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_assign<void*>::value, true); +#ifndef TEST_STD +// unspecified behaviour: +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_assign<int*const>::value, false); +#endif +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_assign<f1>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_assign<f2>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_assign<f3>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_assign<mf1>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_assign<mf2>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_assign<mf3>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_assign<mp>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_assign<cmf>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_assign<enum_UDT>::value, true); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_assign<int&>::value, false); +#ifndef BOOST_NO_RVALUE_REFERENCES +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_assign<int&&>::value, false); +#endif +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_assign<const int&>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_assign<int[2]>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_assign<int[3][2]>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_assign<int[2][4][5][6][3]>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_assign<UDT>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_assign<empty_UDT>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_assign<void>::value, false); +// cases we would like to succeed but can't implement in the language: +BOOST_CHECK_SOFT_INTEGRAL_CONSTANT(::tt::has_nothrow_assign<empty_POD_UDT>::value, true, false); +BOOST_CHECK_SOFT_INTEGRAL_CONSTANT(::tt::has_nothrow_assign<POD_UDT>::value, true, false); +BOOST_CHECK_SOFT_INTEGRAL_CONSTANT(::tt::has_nothrow_assign<POD_union_UDT>::value, true, false); +BOOST_CHECK_SOFT_INTEGRAL_CONSTANT(::tt::has_nothrow_assign<empty_POD_union_UDT>::value, true, false); +BOOST_CHECK_SOFT_INTEGRAL_CONSTANT(::tt::has_nothrow_assign<nothrow_assign_UDT>::value, true, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_assign<nothrow_copy_UDT>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_assign<nothrow_construct_UDT>::value, false); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_assign<test_abc1>::value, false); + +TT_TEST_END + + + diff --git a/libs/type_traits/test/has_nothrow_constr_test.cpp b/libs/type_traits/test/has_nothrow_constr_test.cpp new file mode 100644 index 0000000000..94bce1ef3b --- /dev/null +++ b/libs/type_traits/test/has_nothrow_constr_test.cpp @@ -0,0 +1,169 @@ + +// (C) Copyright John Maddock 2000. +// 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/has_nothrow_constructor.hpp> +#endif + +TT_TEST_BEGIN(has_nothrow_constructor) + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_constructor<bool>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_constructor<bool const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_constructor<bool volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_constructor<bool const volatile>::value, true); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_constructor<signed char>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_constructor<signed char const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_constructor<signed char volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_constructor<signed char const volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_constructor<unsigned char>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_constructor<char>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_constructor<unsigned char const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_constructor<char const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_constructor<unsigned char volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_constructor<char volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_constructor<unsigned char const volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_constructor<char const volatile>::value, true); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_constructor<unsigned short>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_constructor<short>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_constructor<unsigned short const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_constructor<short const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_constructor<unsigned short volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_constructor<short volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_constructor<unsigned short const volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_constructor<short const volatile>::value, true); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_constructor<unsigned int>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_constructor<int>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_constructor<unsigned int const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_constructor<int const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_constructor<unsigned int volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_constructor<int volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_constructor<unsigned int const volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_constructor<int const volatile>::value, true); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_constructor<unsigned long>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_constructor<long>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_constructor<unsigned long const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_constructor<long const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_constructor<unsigned long volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_constructor<long volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_constructor<unsigned long const volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_constructor<long const volatile>::value, true); + +#ifdef BOOST_HAS_LONG_LONG + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_constructor< ::boost::ulong_long_type>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_constructor< ::boost::long_long_type>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_constructor< ::boost::ulong_long_type const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_constructor< ::boost::long_long_type const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_constructor< ::boost::ulong_long_type volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_constructor< ::boost::long_long_type volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_constructor< ::boost::ulong_long_type const volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_constructor< ::boost::long_long_type const volatile>::value, true); + +#endif + +#ifdef BOOST_HAS_MS_INT64 + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_constructor<unsigned __int8>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_constructor<__int8>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_constructor<unsigned __int8 const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_constructor<__int8 const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_constructor<unsigned __int8 volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_constructor<__int8 volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_constructor<unsigned __int8 const volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_constructor<__int8 const volatile>::value, true); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_constructor<unsigned __int16>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_constructor<__int16>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_constructor<unsigned __int16 const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_constructor<__int16 const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_constructor<unsigned __int16 volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_constructor<__int16 volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_constructor<unsigned __int16 const volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_constructor<__int16 const volatile>::value, true); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_constructor<unsigned __int32>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_constructor<__int32>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_constructor<unsigned __int32 const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_constructor<__int32 const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_constructor<unsigned __int32 volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_constructor<__int32 volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_constructor<unsigned __int32 const volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_constructor<__int32 const volatile>::value, true); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_constructor<unsigned __int64>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_constructor<__int64>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_constructor<unsigned __int64 const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_constructor<__int64 const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_constructor<unsigned __int64 volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_constructor<__int64 volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_constructor<unsigned __int64 const volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_constructor<__int64 const volatile>::value, true); + +#endif + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_constructor<float>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_constructor<float const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_constructor<float volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_constructor<float const volatile>::value, true); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_constructor<double>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_constructor<double const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_constructor<double volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_constructor<double const volatile>::value, true); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_constructor<long double>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_constructor<long double const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_constructor<long double volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_constructor<long double const volatile>::value, true); + + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_constructor<int>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_constructor<void*>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_constructor<int*const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_constructor<f1>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_constructor<f2>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_constructor<f3>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_constructor<mf1>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_constructor<mf2>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_constructor<mf3>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_constructor<mp>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_constructor<cmf>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_constructor<enum_UDT>::value, true); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_constructor<int&>::value, false); +#ifndef BOOST_NO_RVALUE_REFERENCES +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_constructor<int&&>::value, false); +#endif +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_constructor<const int&>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_constructor<int[2]>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_constructor<int[3][2]>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_constructor<int[2][4][5][6][3]>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_constructor<UDT>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_constructor<empty_UDT>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_constructor<void>::value, false); +// cases we would like to succeed but can't implement in the language: +BOOST_CHECK_SOFT_INTEGRAL_CONSTANT(::tt::has_nothrow_constructor<empty_POD_UDT>::value, true, false); +BOOST_CHECK_SOFT_INTEGRAL_CONSTANT(::tt::has_nothrow_constructor<POD_UDT>::value, true, false); +BOOST_CHECK_SOFT_INTEGRAL_CONSTANT(::tt::has_nothrow_constructor<POD_union_UDT>::value, true, false); +BOOST_CHECK_SOFT_INTEGRAL_CONSTANT(::tt::has_nothrow_constructor<empty_POD_union_UDT>::value, true, false); +BOOST_CHECK_SOFT_INTEGRAL_CONSTANT(::tt::has_nothrow_constructor<nothrow_construct_UDT>::value, true, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_constructor<nothrow_assign_UDT>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_constructor<nothrow_copy_UDT>::value, false); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_constructor<test_abc1>::value, false); + +TT_TEST_END + + + diff --git a/libs/type_traits/test/has_nothrow_copy_test.cpp b/libs/type_traits/test/has_nothrow_copy_test.cpp new file mode 100644 index 0000000000..8b993f9765 --- /dev/null +++ b/libs/type_traits/test/has_nothrow_copy_test.cpp @@ -0,0 +1,207 @@ + +// (C) Copyright John Maddock 2000. +// 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/has_nothrow_copy.hpp> +#endif + +TT_TEST_BEGIN(has_nothrow_copy) + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_copy<bool>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_copy<bool const>::value, true); +#ifndef TEST_STD +// unspecified behaviour: +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_copy<bool volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_copy<bool const volatile>::value, false); +#endif + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_copy<signed char>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_copy<signed char const>::value, true); +#ifndef TEST_STD +// unspecified behaviour: +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_copy<signed char volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_copy<signed char const volatile>::value, false); +#endif +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_copy<unsigned char>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_copy<char>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_copy<unsigned char const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_copy<char const>::value, true); +#ifndef TEST_STD +// unspecified behaviour: +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_copy<unsigned char volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_copy<char volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_copy<unsigned char const volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_copy<char const volatile>::value, false); +#endif + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_copy<unsigned short>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_copy<short>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_copy<unsigned short const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_copy<short const>::value, true); +#ifndef TEST_STD +// unspecified behaviour: +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_copy<unsigned short volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_copy<short volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_copy<unsigned short const volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_copy<short const volatile>::value, false); +#endif + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_copy<unsigned int>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_copy<int>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_copy<unsigned int const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_copy<int const>::value, true); +#ifndef TEST_STD +// unspecified behaviour: +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_copy<unsigned int volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_copy<int volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_copy<unsigned int const volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_copy<int const volatile>::value, false); +#endif + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_copy<unsigned long>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_copy<long>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_copy<unsigned long const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_copy<long const>::value, true); +#ifndef TEST_STD +// unspecified behaviour: +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_copy<unsigned long volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_copy<long volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_copy<unsigned long const volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_copy<long const volatile>::value, false); +#endif + +#ifdef BOOST_HAS_LONG_LONG + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_copy< ::boost::ulong_long_type>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_copy< ::boost::long_long_type>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_copy< ::boost::ulong_long_type const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_copy< ::boost::long_long_type const>::value, true); +#ifndef TEST_STD +// unspecified behaviour: +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_copy< ::boost::ulong_long_type volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_copy< ::boost::long_long_type volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_copy< ::boost::ulong_long_type const volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_copy< ::boost::long_long_type const volatile>::value, false); +#endif +#endif + +#ifdef BOOST_HAS_MS_INT64 + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_copy<unsigned __int8>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_copy<__int8>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_copy<unsigned __int8 const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_copy<__int8 const>::value, true); +#ifndef TEST_STD +// unspecified behaviour: +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_copy<unsigned __int8 volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_copy<__int8 volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_copy<unsigned __int8 const volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_copy<__int8 const volatile>::value, false); +#endif + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_copy<unsigned __int16>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_copy<__int16>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_copy<unsigned __int16 const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_copy<__int16 const>::value, true); +#ifndef TEST_STD +// unspecified behaviour: +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_copy<unsigned __int16 volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_copy<__int16 volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_copy<unsigned __int16 const volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_copy<__int16 const volatile>::value, false); +#endif + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_copy<unsigned __int32>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_copy<__int32>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_copy<unsigned __int32 const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_copy<__int32 const>::value, true); +#ifndef TEST_STD +// unspecified behaviour: +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_copy<unsigned __int32 volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_copy<__int32 volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_copy<unsigned __int32 const volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_copy<__int32 const volatile>::value, false); +#endif + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_copy<unsigned __int64>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_copy<__int64>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_copy<unsigned __int64 const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_copy<__int64 const>::value, true); +#ifndef TEST_STD +// unspecified behaviour: +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_copy<unsigned __int64 volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_copy<__int64 volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_copy<unsigned __int64 const volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_copy<__int64 const volatile>::value, false); +#endif +#endif + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_copy<float>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_copy<float const>::value, true); +#ifndef TEST_STD +// unspecified behaviour: +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_copy<float volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_copy<float const volatile>::value, false); +#endif + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_copy<double>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_copy<double const>::value, true); +#ifndef TEST_STD +// unspecified behaviour: +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_copy<double volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_copy<double const volatile>::value, false); +#endif + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_copy<long double>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_copy<long double const>::value, true); +#ifndef TEST_STD +// unspecified behaviour: +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_copy<long double volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_copy<long double const volatile>::value, false); +#endif + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_copy<int>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_copy<void*>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_copy<int*const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_copy<f1>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_copy<f2>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_copy<f3>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_copy<mf1>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_copy<mf2>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_copy<mf3>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_copy<mp>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_copy<cmf>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_copy<enum_UDT>::value, true); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_copy<int&>::value, false); +#ifndef BOOST_NO_RVALUE_REFERENCES +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_copy<int&&>::value, false); +#endif +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_copy<const int&>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_copy<int[2]>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_copy<int[3][2]>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_copy<int[2][4][5][6][3]>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_copy<UDT>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_copy<void>::value, false); +// cases we would like to succeed but can't implement in the language: +BOOST_CHECK_SOFT_INTEGRAL_CONSTANT(::tt::has_nothrow_copy<empty_POD_UDT>::value, true, false); +BOOST_CHECK_SOFT_INTEGRAL_CONSTANT(::tt::has_nothrow_copy<POD_UDT>::value, true, false); +BOOST_CHECK_SOFT_INTEGRAL_CONSTANT(::tt::has_nothrow_copy<POD_union_UDT>::value, true, false); +BOOST_CHECK_SOFT_INTEGRAL_CONSTANT(::tt::has_nothrow_copy<empty_POD_union_UDT>::value, true, false); +BOOST_CHECK_SOFT_INTEGRAL_CONSTANT(::tt::has_nothrow_copy<nothrow_copy_UDT>::value, true, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_copy<nothrow_assign_UDT>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_copy<nothrow_construct_UDT>::value, false); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_nothrow_copy<test_abc1>::value, false); + +TT_TEST_END + + + diff --git a/libs/type_traits/test/has_operator_new_test.cpp b/libs/type_traits/test/has_operator_new_test.cpp new file mode 100644 index 0000000000..da57e48fb1 --- /dev/null +++ b/libs/type_traits/test/has_operator_new_test.cpp @@ -0,0 +1,202 @@ +// (C) Copyright John Maddock 2000. +// 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" +#include <boost/type_traits/has_new_operator.hpp> + +#ifdef BOOST_INTEL +// remark #1720: function "class_with_new_op::operator new" has no corresponding member operator delete (to be called if an exception is thrown during initialization of an allocated object) +// void * operator new(std::size_t); +// ^ +#pragma warning(disable:1720) +#endif + +struct class_with_new_op { + void * operator new(std::size_t); +}; + +struct derived_class_with_new_op : public class_with_new_op {}; + +struct class_with_new_op2 { + void* operator new(std::size_t size, const std::nothrow_t&); +}; + +struct class_with_new_op3 { + void* operator new[](std::size_t size); +}; + +struct class_with_new_op4 { + void* operator new[](std::size_t size, const std::nothrow_t&); +}; + +struct class_with_new_op5 { + void* operator new (std::size_t size, void* ptr); +}; + +struct class_with_new_op6 { + void* operator new[] (std::size_t size, void* ptr); +}; + +struct class_with_all_ops +{ + void * operator new(std::size_t); + void* operator new(std::size_t size, const std::nothrow_t&); + void* operator new[](std::size_t size); + void* operator new[](std::size_t size, const std::nothrow_t&); + void* operator new (std::size_t size, void* ptr); + void* operator new[] (std::size_t size, void* ptr); +}; + +TT_TEST_BEGIN(has_new_operator) + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_new_operator<class_with_new_op>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_new_operator<derived_class_with_new_op>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_new_operator<class_with_new_op2>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_new_operator<class_with_new_op3>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_new_operator<class_with_new_op4>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_new_operator<class_with_new_op5>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_new_operator<class_with_new_op6>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_new_operator<class_with_all_ops>::value, true); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_new_operator<bool>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_new_operator<bool const>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_new_operator<bool volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_new_operator<bool const volatile>::value, false); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_new_operator<signed char>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_new_operator<signed char const>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_new_operator<signed char volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_new_operator<signed char const volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_new_operator<unsigned char>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_new_operator<char>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_new_operator<unsigned char const>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_new_operator<char const>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_new_operator<unsigned char volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_new_operator<char volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_new_operator<unsigned char const volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_new_operator<char const volatile>::value, false); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_new_operator<unsigned short>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_new_operator<short>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_new_operator<unsigned short const>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_new_operator<short const>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_new_operator<unsigned short volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_new_operator<short volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_new_operator<unsigned short const volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_new_operator<short const volatile>::value, false); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_new_operator<unsigned int>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_new_operator<int>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_new_operator<unsigned int const>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_new_operator<int const>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_new_operator<unsigned int volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_new_operator<int volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_new_operator<unsigned int const volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_new_operator<int const volatile>::value, false); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_new_operator<unsigned long>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_new_operator<long>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_new_operator<unsigned long const>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_new_operator<long const>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_new_operator<unsigned long volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_new_operator<long volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_new_operator<unsigned long const volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_new_operator<long const volatile>::value, false); + +#ifdef BOOST_HAS_LONG_LONG + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_new_operator< ::boost::ulong_long_type>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_new_operator< ::boost::long_long_type>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_new_operator< ::boost::ulong_long_type const>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_new_operator< ::boost::long_long_type const>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_new_operator< ::boost::ulong_long_type volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_new_operator< ::boost::long_long_type volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_new_operator< ::boost::ulong_long_type const volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_new_operator< ::boost::long_long_type const volatile>::value, false); + +#endif + +#ifdef BOOST_HAS_MS_INT64 + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_new_operator<unsigned __int8>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_new_operator<__int8>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_new_operator<unsigned __int8 const>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_new_operator<__int8 const>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_new_operator<unsigned __int8 volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_new_operator<__int8 volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_new_operator<unsigned __int8 const volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_new_operator<__int8 const volatile>::value, false); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_new_operator<unsigned __int16>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_new_operator<__int16>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_new_operator<unsigned __int16 const>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_new_operator<__int16 const>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_new_operator<unsigned __int16 volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_new_operator<__int16 volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_new_operator<unsigned __int16 const volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_new_operator<__int16 const volatile>::value, false); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_new_operator<unsigned __int32>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_new_operator<__int32>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_new_operator<unsigned __int32 const>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_new_operator<__int32 const>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_new_operator<unsigned __int32 volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_new_operator<__int32 volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_new_operator<unsigned __int32 const volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_new_operator<__int32 const volatile>::value, false); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_new_operator<unsigned __int64>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_new_operator<__int64>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_new_operator<unsigned __int64 const>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_new_operator<__int64 const>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_new_operator<unsigned __int64 volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_new_operator<__int64 volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_new_operator<unsigned __int64 const volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_new_operator<__int64 const volatile>::value, false); + +#endif + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_new_operator<float>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_new_operator<float const>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_new_operator<float volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_new_operator<float const volatile>::value, false); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_new_operator<double>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_new_operator<double const>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_new_operator<double volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_new_operator<double const volatile>::value, false); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_new_operator<long double>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_new_operator<long double const>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_new_operator<long double volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_new_operator<long double const volatile>::value, false); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_new_operator<int>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_new_operator<void*>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_new_operator<int*const>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_new_operator<f1>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_new_operator<f2>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_new_operator<f3>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_new_operator<mf1>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_new_operator<mf2>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_new_operator<mf3>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_new_operator<mp>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_new_operator<cmf>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_new_operator<enum_UDT>::value, false); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_new_operator<int&>::value, false); +#ifndef BOOST_NO_RVALUE_REFERENCES +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_new_operator<int&&>::value, false); +#endif +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_new_operator<const int&>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_new_operator<int[2]>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_new_operator<int[3][2]>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_new_operator<int[2][4][5][6][3]>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_new_operator<UDT>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_new_operator<empty_UDT>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_new_operator<void>::value, false); + +TT_TEST_END diff --git a/libs/type_traits/test/has_plus_assign_test.cpp b/libs/type_traits/test/has_plus_assign_test.cpp new file mode 100644 index 0000000000..d66c3945df --- /dev/null +++ b/libs/type_traits/test/has_plus_assign_test.cpp @@ -0,0 +1,228 @@ +// (C) Copyright 2009-2011 Frederic Bron. +// 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/has_plus_assign.hpp> +#endif + +#define BOOST_TT_TRAIT_NAME has_plus_assign +#define BOOST_TT_TRAIT_OP += + + +#include "has_binary_operators.hpp" + +void specific() { + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, void, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, int &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, void, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, void, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, void, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, int* & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, void, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, bool, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, bool &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, double &, bool & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, void* &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int*, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int*, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int const &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, double, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, double &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, void* &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int* const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int* &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int* const &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, bool, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, bool const &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, double const, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, double const &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, void*, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, void* const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, void* const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, void* const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int* const, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int* const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, bool const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, int &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, double const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, double &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, double const &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void* &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, int*, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, int* const &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int, int & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int const, int & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, double & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, double &, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, double &, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, double &, int & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, double const &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, void*, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, void* &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, void* &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, void* const &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, void* const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int*, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int* const, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, bool const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, double & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, void*, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, void*, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, void* &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, bool, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, bool &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, bool const &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, int const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, int &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, void*, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, void* const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, void* &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, double, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, double, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, double, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, double &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, double const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, void* const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, bool const, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, bool &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, bool &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, double const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int*, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int* const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, double &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, double &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, double &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, void*, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, void* &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, void* const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, void* const &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int*, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int* const, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int* const, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int* &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, bool &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, bool const &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, double &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, double const &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, void*, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, void* &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, int* const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, bool, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, bool, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int const, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, double &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, double &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int*, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int* & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int* &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int* &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, bool const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, bool const, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, bool &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, bool const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, double const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, double &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, void* &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int* const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int* const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, int &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, void* &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, int*, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, bool, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, bool const &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, bool const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, void* const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int*, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int* &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, bool const &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, double, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, double const &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, double const &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, void* const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, void* const, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, void* &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int*, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int* const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, bool &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int const, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, double const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, double const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, void* const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int* >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int*, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int*, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int*, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, bool const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, bool &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, double >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, double const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, int* &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, int* const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, bool, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, bool &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, double const &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, void* const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, void* &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int* const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool const &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, double &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, double &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, double const &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, void* &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int* >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int* const >::value), 0); + +} + +TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME) + common(); + specific(); +TT_TEST_END diff --git a/libs/type_traits/test/has_plus_test.cpp b/libs/type_traits/test/has_plus_test.cpp new file mode 100644 index 0000000000..af07263828 --- /dev/null +++ b/libs/type_traits/test/has_plus_test.cpp @@ -0,0 +1,228 @@ +// (C) Copyright 2009-2011 Frederic Bron. +// 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/has_plus.hpp> +#endif + +#define BOOST_TT_TRAIT_NAME has_plus +#define BOOST_TT_TRAIT_OP + + + +#include "has_binary_operators.hpp" + +void specific() { + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, void, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, int &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, void, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, void, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, void, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, int* & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, void, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, bool, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, bool &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, double &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, void* &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int*, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int*, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int const &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, double, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, double &, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, void* &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int* const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int* &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int* const &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, bool, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, bool const &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, double const, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, double const &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, void*, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, void* const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, void* const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, void* const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int* const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int* const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, bool & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, bool const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, int &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, double const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, double &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, double const &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void* &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, int*, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, int* const &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, double & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, double &, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, double &, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, double &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, double const &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, void*, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, void* &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, void* &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, void* const &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, void* const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int*, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int* const, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, bool const, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, bool & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, double & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, void*, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, void*, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, void* &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, bool, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, bool &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, bool const &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, int const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, int &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, void*, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, void* const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, void* &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, double, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, double, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, double, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, double &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, double const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, void* const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, bool const, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, bool &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, bool &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, double const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int*, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int* const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, double &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, double &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, double &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, void*, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, void* &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, void* const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, void* const &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int*, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int* const, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int* const, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int* &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, bool &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, bool const &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, double &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, double const &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, void*, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, void* &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, int* const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, bool, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, bool, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int const, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, double &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, double &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int*, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int* & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int* &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int* &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, bool const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, bool const, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, bool &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, bool const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, double const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, double &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, void* &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int* const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int* const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, int &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, void* &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, int*, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, bool, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, bool const &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, bool const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, void* const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int*, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int* &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, bool const &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, double, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, double const &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, double const &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, void* const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, void* const, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, void* &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int*, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int* const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, bool &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int const, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, double const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, double const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, void* const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int* >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int*, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int*, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int*, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, bool const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, bool &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, double >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, double const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, int* &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, int* const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, bool, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, bool &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, double const &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, void* const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, void* &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int* const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool const &, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int const, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, double &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, double &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, double const &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, void* &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int* >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int* const >::value), 0); + +} + +TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME) + common(); + specific(); +TT_TEST_END diff --git a/libs/type_traits/test/has_post_decrement_test.cpp b/libs/type_traits/test/has_post_decrement_test.cpp new file mode 100644 index 0000000000..bae2c62ba5 --- /dev/null +++ b/libs/type_traits/test/has_post_decrement_test.cpp @@ -0,0 +1,228 @@ +// (C) Copyright 2009-2011 Frederic Bron. +// 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/has_post_decrement.hpp> +#endif + +#define BOOST_TT_TRAIT_NAME has_post_decrement +#define BOOST_TT_TRAIT_OP -- + + +#include "has_postfix_operators.hpp" + +void specific() { + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int const & >::value), 0); + +} + +TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME) + common(); + specific(); +TT_TEST_END diff --git a/libs/type_traits/test/has_post_increment_test.cpp b/libs/type_traits/test/has_post_increment_test.cpp new file mode 100644 index 0000000000..f96e884727 --- /dev/null +++ b/libs/type_traits/test/has_post_increment_test.cpp @@ -0,0 +1,228 @@ +// (C) Copyright 2009-2011 Frederic Bron. +// 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/has_post_increment.hpp> +#endif + +#define BOOST_TT_TRAIT_NAME has_post_increment +#define BOOST_TT_TRAIT_OP ++ + + +#include "has_postfix_operators.hpp" + +void specific() { + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int const & >::value), 0); + +} + +TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME) + common(); + specific(); +TT_TEST_END diff --git a/libs/type_traits/test/has_postfix_classes.hpp b/libs/type_traits/test/has_postfix_classes.hpp new file mode 100644 index 0000000000..b01f07d5f9 --- /dev/null +++ b/libs/type_traits/test/has_postfix_classes.hpp @@ -0,0 +1,72 @@ +// (C) Copyright Frederic Bron 2009-2011. +// 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) + +#ifndef TT_HAS_POSTFIX_CLASSES_HPP +#define TT_HAS_POSTFIX_CLASSES_HPP + +struct ret { }; +ret ret_val; + +class C000 { C000(); public: C000(int) { } }; +void operator++(C000, int) { } + +class C001 { C001(); public: C001(int) { } }; +ret operator++(C001, int) { return ret_val; } + +class C002 { C002(); public: C002(int) { } }; +ret const operator++(C002, int) { return ret_val; } + +class C005 { C005(); public: C005(int) { } }; +ret & operator++(C005, int) { return ret_val; } + +class C006 { C006(); public: C006(int) { } }; +ret const & operator++(C006, int) { return ret_val; } + +class C009 { C009(); public: C009(int) { } }; +void operator++(C009 const, int) { } + +class C010 { C010(); public: C010(int) { } }; +ret operator++(C010 const, int) { return ret_val; } + +class C011 { C011(); public: C011(int) { } }; +ret const operator++(C011 const, int) { return ret_val; } + +class C014 { C014(); public: C014(int) { } }; +ret & operator++(C014 const, int) { return ret_val; } + +class C015 { C015(); public: C015(int) { } }; +ret const & operator++(C015 const, int) { return ret_val; } + +class C036 { C036(); public: C036(int) { } }; +void operator++(C036 &, int) { } + +class C037 { C037(); public: C037(int) { } }; +ret operator++(C037 &, int) { return ret_val; } + +class C038 { C038(); public: C038(int) { } }; +ret const operator++(C038 &, int) { return ret_val; } + +class C041 { C041(); public: C041(int) { } }; +ret & operator++(C041 &, int) { return ret_val; } + +class C042 { C042(); public: C042(int) { } }; +ret const & operator++(C042 &, int) { return ret_val; } + +class C045 { C045(); public: C045(int) { } }; +void operator++(C045 const &, int) { } + +class C046 { C046(); public: C046(int) { } }; +ret operator++(C046 const &, int) { return ret_val; } + +class C047 { C047(); public: C047(int) { } }; +ret const operator++(C047 const &, int) { return ret_val; } + +class C050 { C050(); public: C050(int) { } }; +ret & operator++(C050 const &, int) { return ret_val; } + +class C051 { C051(); public: C051(int) { } }; +ret const & operator++(C051 const &, int) { return ret_val; } + +#endif diff --git a/libs/type_traits/test/has_postfix_classes0_test.cpp b/libs/type_traits/test/has_postfix_classes0_test.cpp new file mode 100644 index 0000000000..d3affa1417 --- /dev/null +++ b/libs/type_traits/test/has_postfix_classes0_test.cpp @@ -0,0 +1,113 @@ +// (C) Copyright 2009-2011 Frederic Bron. +// 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" + +#include <boost/type_traits/has_operator.hpp> +#include "has_postfix_classes.hpp" + +TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME) + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C000, void >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C000, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C000, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C000, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C000, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C000 const, void >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C000 const, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C000 const, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C000 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C000 const, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C000 &, void >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C000 &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C000 &, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C000 &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C000 &, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C000 const &, void >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C000 const &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C000 const &, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C000 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C000 const &, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C001, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C001, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C001, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C001, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C001, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C001 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C001 const, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C001 const, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C001 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C001 const, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C001 &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C001 &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C001 &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C001 &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C001 &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C001 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C001 const &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C001 const &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C001 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C001 const &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C002, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C002, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C002, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C002, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C002, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C002 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C002 const, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C002 const, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C002 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C002 const, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C002 &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C002 &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C002 &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C002 &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C002 &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C002 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C002 const &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C002 const &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C002 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C002 const &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C005, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C005, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C005, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C005, ret & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C005, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C005 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C005 const, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C005 const, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C005 const, ret & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C005 const, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C005 &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C005 &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C005 &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C005 &, ret & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C005 &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C005 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C005 const &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C005 const &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C005 const &, ret & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C005 const &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C006, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C006, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C006, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C006, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C006, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C006 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C006 const, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C006 const, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C006 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C006 const, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C006 &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C006 &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C006 &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C006 &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C006 &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C006 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C006 const &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C006 const &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C006 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C006 const &, ret const & >::value), 1); +TT_TEST_END diff --git a/libs/type_traits/test/has_postfix_classes1_test.cpp b/libs/type_traits/test/has_postfix_classes1_test.cpp new file mode 100644 index 0000000000..0d0ab8adb4 --- /dev/null +++ b/libs/type_traits/test/has_postfix_classes1_test.cpp @@ -0,0 +1,113 @@ +// (C) Copyright 2009-2011 Frederic Bron. +// 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" + +#include <boost/type_traits/has_operator.hpp> +#include "has_postfix_classes.hpp" + +TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME) + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C009, void >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C009, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C009, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C009, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C009, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C009 const, void >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C009 const, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C009 const, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C009 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C009 const, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C009 &, void >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C009 &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C009 &, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C009 &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C009 &, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C009 const &, void >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C009 const &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C009 const &, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C009 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C009 const &, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C010, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C010, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C010, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C010, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C010, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C010 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C010 const, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C010 const, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C010 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C010 const, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C010 &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C010 &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C010 &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C010 &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C010 &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C010 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C010 const &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C010 const &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C010 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C010 const &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C011, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C011, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C011, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C011, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C011, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C011 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C011 const, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C011 const, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C011 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C011 const, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C011 &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C011 &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C011 &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C011 &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C011 &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C011 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C011 const &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C011 const &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C011 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C011 const &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C014, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C014, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C014, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C014, ret & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C014, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C014 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C014 const, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C014 const, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C014 const, ret & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C014 const, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C014 &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C014 &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C014 &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C014 &, ret & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C014 &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C014 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C014 const &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C014 const &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C014 const &, ret & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C014 const &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C015, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C015, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C015, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C015, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C015, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C015 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C015 const, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C015 const, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C015 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C015 const, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C015 &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C015 &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C015 &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C015 &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C015 &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C015 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C015 const &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C015 const &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C015 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C015 const &, ret const & >::value), 1); +TT_TEST_END diff --git a/libs/type_traits/test/has_postfix_classes2_test.cpp b/libs/type_traits/test/has_postfix_classes2_test.cpp new file mode 100644 index 0000000000..aa01ecb8c6 --- /dev/null +++ b/libs/type_traits/test/has_postfix_classes2_test.cpp @@ -0,0 +1,113 @@ +// (C) Copyright 2009-2011 Frederic Bron. +// 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" + +#include <boost/type_traits/has_operator.hpp> +#include "has_postfix_classes.hpp" + +TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME) + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C036, void >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C036, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C036, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C036, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C036, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C036 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C036 const, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C036 const, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C036 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C036 const, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C036 &, void >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C036 &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C036 &, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C036 &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C036 &, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C036 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C036 const &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C036 const &, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C036 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C036 const &, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C037, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C037, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C037, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C037, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C037, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C037 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C037 const, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C037 const, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C037 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C037 const, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C037 &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C037 &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C037 &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C037 &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C037 &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C037 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C037 const &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C037 const &, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C037 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C037 const &, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C038, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C038, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C038, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C038, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C038, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C038 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C038 const, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C038 const, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C038 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C038 const, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C038 &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C038 &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C038 &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C038 &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C038 &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C038 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C038 const &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C038 const &, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C038 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C038 const &, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C041, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C041, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C041, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C041, ret & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C041, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C041 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C041 const, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C041 const, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C041 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C041 const, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C041 &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C041 &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C041 &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C041 &, ret & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C041 &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C041 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C041 const &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C041 const &, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C041 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C041 const &, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C042, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C042, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C042, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C042, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C042, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C042 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C042 const, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C042 const, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C042 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C042 const, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C042 &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C042 &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C042 &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C042 &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C042 &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C042 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C042 const &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C042 const &, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C042 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C042 const &, ret const & >::value), 0); +TT_TEST_END diff --git a/libs/type_traits/test/has_postfix_classes3_test.cpp b/libs/type_traits/test/has_postfix_classes3_test.cpp new file mode 100644 index 0000000000..e0070692c3 --- /dev/null +++ b/libs/type_traits/test/has_postfix_classes3_test.cpp @@ -0,0 +1,113 @@ +// (C) Copyright 2009-2011 Frederic Bron. +// 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" + +#include <boost/type_traits/has_operator.hpp> +#include "has_postfix_classes.hpp" + +TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME) + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C045, void >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C045, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C045, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C045, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C045, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C045 const, void >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C045 const, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C045 const, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C045 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C045 const, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C045 &, void >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C045 &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C045 &, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C045 &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C045 &, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C045 const &, void >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C045 const &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C045 const &, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C045 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C045 const &, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C046, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C046, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C046, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C046, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C046, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C046 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C046 const, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C046 const, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C046 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C046 const, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C046 &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C046 &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C046 &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C046 &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C046 &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C046 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C046 const &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C046 const &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C046 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C046 const &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C047, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C047, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C047, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C047, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C047, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C047 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C047 const, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C047 const, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C047 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C047 const, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C047 &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C047 &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C047 &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C047 &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C047 &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C047 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C047 const &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C047 const &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C047 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C047 const &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C050, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C050, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C050, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C050, ret & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C050, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C050 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C050 const, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C050 const, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C050 const, ret & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C050 const, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C050 &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C050 &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C050 &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C050 &, ret & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C050 &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C050 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C050 const &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C050 const &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C050 const &, ret & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C050 const &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C051, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C051, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C051, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C051, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C051, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C051 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C051 const, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C051 const, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C051 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C051 const, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C051 &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C051 &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C051 &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C051 &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C051 &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C051 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C051 const &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C051 const &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C051 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_post_increment< C051 const &, ret const & >::value), 1); +TT_TEST_END diff --git a/libs/type_traits/test/has_postfix_operators.hpp b/libs/type_traits/test/has_postfix_operators.hpp new file mode 100644 index 0000000000..3348ca5515 --- /dev/null +++ b/libs/type_traits/test/has_postfix_operators.hpp @@ -0,0 +1,131 @@ +// (C) Copyright Frederic Bron 2009-2011. +// 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) + +#ifndef TT_HAS_POSTFIX_OPERATORS_HPP +#define TT_HAS_POSTFIX_OPERATORS_HPP + +// test with one template parameter +#define TEST_T(TYPE,RESULT) BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME<TYPE>::value), RESULT) +// test with one template parameter plus return value +#define TEST_TR(TYPE,RET,RESULT) BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME<TYPE,RET>::value), RESULT) + +namespace { + +struct without { }; + +struct ret { }; + +struct internal { ret operator BOOST_TT_TRAIT_OP (int) const; }; + +struct external { }; +ret operator BOOST_TT_TRAIT_OP (const external&, int); + +struct comma1_ret { }; +struct ret_with_comma1 { comma1_ret operator,(int); }; + +struct internal_comma1 { ret_with_comma1 operator BOOST_TT_TRAIT_OP (int) const; }; + +struct external_comma1 { }; +ret_with_comma1 operator BOOST_TT_TRAIT_OP (const external_comma1&, int); + +struct ret_with_comma2 { void operator,(int); }; + +struct internal_comma2 { ret_with_comma2 operator BOOST_TT_TRAIT_OP (int) const; }; + +struct external_comma2 { }; +ret_with_comma2 operator BOOST_TT_TRAIT_OP (const external_comma2&, int); + +struct returns_int { int operator BOOST_TT_TRAIT_OP (int); }; + +struct returns_void { void operator BOOST_TT_TRAIT_OP (int); }; + +struct returns_void_star { void *operator BOOST_TT_TRAIT_OP (int); }; + +struct returns_double { double operator BOOST_TT_TRAIT_OP (int); }; + +struct ret1 { }; +struct convertible_to_ret1 { operator ret1 () const; }; +struct returns_convertible_to_ret1 { convertible_to_ret1 operator BOOST_TT_TRAIT_OP (int); }; + +struct convertible_to_ret2 { }; +struct ret2 { ret2(const convertible_to_ret2); }; +struct returns_convertible_to_ret2 { convertible_to_ret2 operator BOOST_TT_TRAIT_OP (int); }; + +class Base1 { }; +class Derived1 : public Base1 { }; + +bool operator BOOST_TT_TRAIT_OP (const Base1&, int) { return true; } + +class Base2 { }; +struct Derived2 : public Base2 { + Derived2(int); // to check if it works with a class that is not default constructible +}; + +bool operator BOOST_TT_TRAIT_OP (const Derived2&, int) { return true; } + +struct tag { }; + +//class internal_private { ret operator BOOST_TT_TRAIT_OP (int) const; }; + +void common() { + TEST_T(void, false); + TEST_TR(void, void, false); + TEST_TR(void, int, false); + + TEST_T(without, false); + TEST_T(internal, true); + TEST_T(external, true); + TEST_T(internal_comma1, true); + TEST_T(external_comma1, true); + TEST_T(internal_comma2, true); + TEST_T(external_comma2, true); + TEST_T(returns_int, true); + TEST_T(returns_void, true); + TEST_T(returns_void_star, true); + TEST_T(returns_double, true); + TEST_T(returns_convertible_to_ret1, true); + TEST_T(returns_convertible_to_ret2, true); + TEST_T(Base1, true); + TEST_T(Derived1, true); + TEST_T(Base2, false); + TEST_T(Derived2, true); + + TEST_TR(without, void, false); + TEST_TR(without, bool, false); + TEST_TR(internal, void, false); + TEST_TR(internal, bool, false); + TEST_TR(internal, ret, true); + TEST_TR(internal_comma1, void, false); + TEST_TR(internal_comma1, bool, false); + TEST_TR(internal_comma1, ret_with_comma1, true); + TEST_TR(internal_comma2, void, false); + TEST_TR(internal_comma2, bool, false); + TEST_TR(internal_comma2, ret_with_comma2, true); + TEST_TR(external, void, false); + TEST_TR(external, bool, false); + TEST_TR(external, ret, true); + TEST_TR(returns_int, void, false); + TEST_TR(returns_int, bool, true); + TEST_TR(returns_int, int, true); + TEST_TR(returns_void, void, true); + TEST_TR(returns_void, bool, false); + TEST_TR(returns_void_star, bool, true); + TEST_TR(returns_double, void, false); + TEST_TR(returns_double, bool, true); + TEST_TR(returns_double, double, true); + TEST_TR(returns_convertible_to_ret1, void, false); + TEST_TR(returns_convertible_to_ret1, ret1, true); + TEST_TR(returns_convertible_to_ret2, ret2, true); + TEST_TR(Base1, bool, true); + TEST_TR(Derived1, bool, true); + TEST_TR(Base2, bool, false); + TEST_TR(Derived2, bool, true); +// compile time error +// TEST_T(internal_private, false); +} + +} + +#endif diff --git a/libs/type_traits/test/has_pre_decrement_test.cpp b/libs/type_traits/test/has_pre_decrement_test.cpp new file mode 100644 index 0000000000..e02d7812cc --- /dev/null +++ b/libs/type_traits/test/has_pre_decrement_test.cpp @@ -0,0 +1,228 @@ +// (C) Copyright 2009-2011 Frederic Bron. +// 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/has_pre_decrement.hpp> +#endif + +#define BOOST_TT_TRAIT_NAME has_pre_decrement +#define BOOST_TT_TRAIT_OP -- + + +#include "has_prefix_operators.hpp" + +void specific() { + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, int & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int const & >::value), 0); + +} + +TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME) + common(); + specific(); +TT_TEST_END diff --git a/libs/type_traits/test/has_pre_increment_test.cpp b/libs/type_traits/test/has_pre_increment_test.cpp new file mode 100644 index 0000000000..deeb9fece7 --- /dev/null +++ b/libs/type_traits/test/has_pre_increment_test.cpp @@ -0,0 +1,228 @@ +// (C) Copyright 2009-2011 Frederic Bron. +// 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/has_pre_increment.hpp> +#endif + +#define BOOST_TT_TRAIT_NAME has_pre_increment +#define BOOST_TT_TRAIT_OP ++ + + +#include "has_prefix_operators.hpp" + +void specific() { + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, int & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int const & >::value), 0); + +} + +TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME) + common(); + specific(); +TT_TEST_END diff --git a/libs/type_traits/test/has_prefix_classes.hpp b/libs/type_traits/test/has_prefix_classes.hpp new file mode 100644 index 0000000000..ac962032b6 --- /dev/null +++ b/libs/type_traits/test/has_prefix_classes.hpp @@ -0,0 +1,72 @@ +// (C) Copyright Frederic Bron 2009-2011. +// 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) + +#ifndef TT_HAS_PREFIX_CLASSES_HPP +#define TT_HAS_PREFIX_CLASSES_HPP + +struct ret { }; +ret ret_val; + +class C000 { C000(); public: C000(int) { } }; +void operator++(C000) { } + +class C001 { C001(); public: C001(int) { } }; +ret operator++(C001) { return ret_val; } + +class C002 { C002(); public: C002(int) { } }; +ret const operator++(C002) { return ret_val; } + +class C005 { C005(); public: C005(int) { } }; +ret & operator++(C005) { return ret_val; } + +class C006 { C006(); public: C006(int) { } }; +ret const & operator++(C006) { return ret_val; } + +class C009 { C009(); public: C009(int) { } }; +void operator++(C009 const) { } + +class C010 { C010(); public: C010(int) { } }; +ret operator++(C010 const) { return ret_val; } + +class C011 { C011(); public: C011(int) { } }; +ret const operator++(C011 const) { return ret_val; } + +class C014 { C014(); public: C014(int) { } }; +ret & operator++(C014 const) { return ret_val; } + +class C015 { C015(); public: C015(int) { } }; +ret const & operator++(C015 const) { return ret_val; } + +class C036 { C036(); public: C036(int) { } }; +void operator++(C036 &) { } + +class C037 { C037(); public: C037(int) { } }; +ret operator++(C037 &) { return ret_val; } + +class C038 { C038(); public: C038(int) { } }; +ret const operator++(C038 &) { return ret_val; } + +class C041 { C041(); public: C041(int) { } }; +ret & operator++(C041 &) { return ret_val; } + +class C042 { C042(); public: C042(int) { } }; +ret const & operator++(C042 &) { return ret_val; } + +class C045 { C045(); public: C045(int) { } }; +void operator++(C045 const &) { } + +class C046 { C046(); public: C046(int) { } }; +ret operator++(C046 const &) { return ret_val; } + +class C047 { C047(); public: C047(int) { } }; +ret const operator++(C047 const &) { return ret_val; } + +class C050 { C050(); public: C050(int) { } }; +ret & operator++(C050 const &) { return ret_val; } + +class C051 { C051(); public: C051(int) { } }; +ret const & operator++(C051 const &) { return ret_val; } + +#endif diff --git a/libs/type_traits/test/has_prefix_classes0_test.cpp b/libs/type_traits/test/has_prefix_classes0_test.cpp new file mode 100644 index 0000000000..130c630c39 --- /dev/null +++ b/libs/type_traits/test/has_prefix_classes0_test.cpp @@ -0,0 +1,113 @@ +// (C) Copyright 2009-2011 Frederic Bron. +// 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" + +#include <boost/type_traits/has_operator.hpp> +#include "has_prefix_classes.hpp" + +TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME) + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C000, void >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C000, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C000, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C000, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C000, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C000 const, void >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C000 const, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C000 const, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C000 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C000 const, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C000 &, void >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C000 &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C000 &, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C000 &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C000 &, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C000 const &, void >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C000 const &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C000 const &, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C000 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C000 const &, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C001, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C001, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C001, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C001, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C001, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C001 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C001 const, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C001 const, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C001 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C001 const, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C001 &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C001 &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C001 &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C001 &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C001 &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C001 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C001 const &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C001 const &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C001 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C001 const &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C002, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C002, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C002, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C002, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C002, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C002 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C002 const, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C002 const, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C002 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C002 const, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C002 &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C002 &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C002 &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C002 &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C002 &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C002 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C002 const &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C002 const &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C002 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C002 const &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C005, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C005, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C005, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C005, ret & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C005, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C005 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C005 const, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C005 const, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C005 const, ret & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C005 const, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C005 &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C005 &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C005 &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C005 &, ret & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C005 &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C005 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C005 const &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C005 const &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C005 const &, ret & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C005 const &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C006, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C006, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C006, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C006, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C006, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C006 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C006 const, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C006 const, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C006 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C006 const, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C006 &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C006 &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C006 &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C006 &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C006 &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C006 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C006 const &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C006 const &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C006 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C006 const &, ret const & >::value), 1); +TT_TEST_END diff --git a/libs/type_traits/test/has_prefix_classes1_test.cpp b/libs/type_traits/test/has_prefix_classes1_test.cpp new file mode 100644 index 0000000000..959ccc06d7 --- /dev/null +++ b/libs/type_traits/test/has_prefix_classes1_test.cpp @@ -0,0 +1,113 @@ +// (C) Copyright 2009-2011 Frederic Bron. +// 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" + +#include <boost/type_traits/has_operator.hpp> +#include "has_prefix_classes.hpp" + +TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME) + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C009, void >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C009, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C009, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C009, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C009, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C009 const, void >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C009 const, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C009 const, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C009 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C009 const, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C009 &, void >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C009 &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C009 &, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C009 &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C009 &, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C009 const &, void >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C009 const &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C009 const &, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C009 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C009 const &, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C010, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C010, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C010, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C010, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C010, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C010 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C010 const, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C010 const, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C010 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C010 const, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C010 &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C010 &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C010 &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C010 &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C010 &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C010 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C010 const &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C010 const &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C010 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C010 const &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C011, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C011, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C011, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C011, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C011, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C011 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C011 const, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C011 const, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C011 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C011 const, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C011 &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C011 &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C011 &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C011 &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C011 &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C011 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C011 const &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C011 const &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C011 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C011 const &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C014, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C014, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C014, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C014, ret & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C014, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C014 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C014 const, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C014 const, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C014 const, ret & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C014 const, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C014 &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C014 &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C014 &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C014 &, ret & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C014 &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C014 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C014 const &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C014 const &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C014 const &, ret & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C014 const &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C015, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C015, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C015, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C015, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C015, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C015 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C015 const, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C015 const, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C015 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C015 const, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C015 &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C015 &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C015 &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C015 &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C015 &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C015 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C015 const &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C015 const &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C015 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C015 const &, ret const & >::value), 1); +TT_TEST_END diff --git a/libs/type_traits/test/has_prefix_classes2_test.cpp b/libs/type_traits/test/has_prefix_classes2_test.cpp new file mode 100644 index 0000000000..6bd716b498 --- /dev/null +++ b/libs/type_traits/test/has_prefix_classes2_test.cpp @@ -0,0 +1,113 @@ +// (C) Copyright 2009-2011 Frederic Bron. +// 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" + +#include <boost/type_traits/has_operator.hpp> +#include "has_prefix_classes.hpp" + +TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME) + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C036, void >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C036, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C036, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C036, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C036, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C036 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C036 const, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C036 const, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C036 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C036 const, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C036 &, void >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C036 &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C036 &, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C036 &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C036 &, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C036 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C036 const &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C036 const &, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C036 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C036 const &, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C037, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C037, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C037, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C037, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C037, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C037 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C037 const, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C037 const, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C037 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C037 const, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C037 &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C037 &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C037 &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C037 &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C037 &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C037 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C037 const &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C037 const &, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C037 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C037 const &, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C038, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C038, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C038, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C038, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C038, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C038 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C038 const, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C038 const, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C038 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C038 const, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C038 &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C038 &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C038 &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C038 &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C038 &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C038 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C038 const &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C038 const &, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C038 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C038 const &, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C041, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C041, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C041, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C041, ret & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C041, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C041 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C041 const, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C041 const, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C041 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C041 const, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C041 &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C041 &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C041 &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C041 &, ret & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C041 &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C041 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C041 const &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C041 const &, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C041 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C041 const &, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C042, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C042, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C042, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C042, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C042, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C042 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C042 const, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C042 const, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C042 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C042 const, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C042 &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C042 &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C042 &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C042 &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C042 &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C042 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C042 const &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C042 const &, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C042 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C042 const &, ret const & >::value), 0); +TT_TEST_END diff --git a/libs/type_traits/test/has_prefix_classes3_test.cpp b/libs/type_traits/test/has_prefix_classes3_test.cpp new file mode 100644 index 0000000000..06b56d6b26 --- /dev/null +++ b/libs/type_traits/test/has_prefix_classes3_test.cpp @@ -0,0 +1,113 @@ +// (C) Copyright 2009-2011 Frederic Bron. +// 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" + +#include <boost/type_traits/has_operator.hpp> +#include "has_prefix_classes.hpp" + +TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME) + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C045, void >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C045, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C045, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C045, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C045, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C045 const, void >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C045 const, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C045 const, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C045 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C045 const, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C045 &, void >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C045 &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C045 &, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C045 &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C045 &, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C045 const &, void >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C045 const &, ret >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C045 const &, ret const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C045 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C045 const &, ret const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C046, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C046, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C046, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C046, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C046, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C046 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C046 const, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C046 const, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C046 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C046 const, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C046 &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C046 &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C046 &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C046 &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C046 &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C046 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C046 const &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C046 const &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C046 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C046 const &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C047, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C047, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C047, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C047, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C047, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C047 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C047 const, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C047 const, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C047 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C047 const, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C047 &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C047 &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C047 &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C047 &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C047 &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C047 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C047 const &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C047 const &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C047 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C047 const &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C050, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C050, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C050, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C050, ret & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C050, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C050 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C050 const, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C050 const, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C050 const, ret & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C050 const, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C050 &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C050 &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C050 &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C050 &, ret & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C050 &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C050 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C050 const &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C050 const &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C050 const &, ret & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C050 const &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C051, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C051, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C051, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C051, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C051, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C051 const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C051 const, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C051 const, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C051 const, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C051 const, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C051 &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C051 &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C051 &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C051 &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C051 &, ret const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C051 const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C051 const &, ret >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C051 const &, ret const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C051 const &, ret & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::has_pre_increment< C051 const &, ret const & >::value), 1); +TT_TEST_END diff --git a/libs/type_traits/test/has_prefix_operators.hpp b/libs/type_traits/test/has_prefix_operators.hpp new file mode 100644 index 0000000000..24646bb7ea --- /dev/null +++ b/libs/type_traits/test/has_prefix_operators.hpp @@ -0,0 +1,128 @@ +// (C) Copyright Frederic Bron 2009-2011. +// 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) + +#ifndef TT_HAS_PREFIX_OPERATORS_HPP +#define TT_HAS_PREFIX_OPERATORS_HPP + +// test with one template parameter +#define TEST_T(TYPE,RESULT) BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME<TYPE>::value), RESULT) +// test with one template parameter plus return value +#define TEST_TR(TYPE,RET,RESULT) BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME<TYPE,RET>::value), RESULT) + +namespace { + +struct without { }; + +struct ret { }; + +struct internal { ret operator BOOST_TT_TRAIT_OP () const; }; + +struct external { }; +ret operator BOOST_TT_TRAIT_OP (const external&); + +struct comma1_ret { }; +struct ret_with_comma1 { comma1_ret operator,(int); }; + +struct internal_comma1 { ret_with_comma1 operator BOOST_TT_TRAIT_OP () const; }; + +struct external_comma1 { }; +ret_with_comma1 operator BOOST_TT_TRAIT_OP (const external_comma1&); + +struct ret_with_comma2 { void operator,(int); }; + +struct internal_comma2 { ret_with_comma2 operator BOOST_TT_TRAIT_OP () const; }; + +struct external_comma2 { }; +ret_with_comma2 operator BOOST_TT_TRAIT_OP (const external_comma2&); + +struct returns_int { int operator BOOST_TT_TRAIT_OP (); }; + +struct returns_void { void operator BOOST_TT_TRAIT_OP (); }; + +struct returns_void_star { void *operator BOOST_TT_TRAIT_OP (); }; + +struct returns_double { double operator BOOST_TT_TRAIT_OP (); }; + +struct ret1 { }; +struct convertible_to_ret1 { operator ret1 () const; }; +struct returns_convertible_to_ret1 { convertible_to_ret1 operator BOOST_TT_TRAIT_OP (); }; + +struct convertible_to_ret2 { }; +struct ret2 { ret2(const convertible_to_ret2); }; +struct returns_convertible_to_ret2 { convertible_to_ret2 operator BOOST_TT_TRAIT_OP (); }; + +class Base1 { }; +class Derived1 : public Base1 { }; + +bool operator BOOST_TT_TRAIT_OP (const Base1&) { return true; } + +class Base2 { }; +struct Derived2 : public Base2 { + Derived2(int); // to check if it works with a class that is not default constructible +}; + +bool operator BOOST_TT_TRAIT_OP (const Derived2&) { return true; } + +struct tag { }; + +//class internal_private { ret operator BOOST_TT_TRAIT_OP () const; }; + +void common() { + TEST_T(void, false); + TEST_TR(void, void, false); + TEST_TR(void, int, false); + + TEST_T(without, false); + TEST_T(internal, true); + TEST_T(external, true); + TEST_T(internal_comma1, true); + TEST_T(external_comma1, true); + TEST_T(internal_comma2, true); + TEST_T(external_comma2, true); + TEST_T(returns_int, true); + TEST_T(returns_void, true); + TEST_T(returns_void_star, true); + TEST_T(returns_double, true); + TEST_T(returns_convertible_to_ret1, true); + TEST_T(returns_convertible_to_ret2, true); + TEST_T(Base1, true); + TEST_T(Derived1, true); + TEST_T(Base2, false); + TEST_T(Derived2, true); + + TEST_TR(without, void, false); + TEST_TR(without, bool, false); + TEST_TR(internal_comma1, void, false); + TEST_TR(internal_comma1, bool, false); + TEST_TR(internal_comma1, ret_with_comma1, true); + TEST_TR(internal_comma2, void, false); + TEST_TR(internal_comma2, bool, false); + TEST_TR(internal_comma2, ret_with_comma2, true); + TEST_TR(external, void, false); + TEST_TR(external, bool, false); + TEST_TR(external, ret, true); + TEST_TR(returns_int, void, false); + TEST_TR(returns_int, bool, true); + TEST_TR(returns_int, int, true); + TEST_TR(returns_void, void, true); + TEST_TR(returns_void, bool, false); + TEST_TR(returns_void_star, bool, true); + TEST_TR(returns_double, void, false); + TEST_TR(returns_double, bool, true); + TEST_TR(returns_double, double, true); + TEST_TR(returns_convertible_to_ret1, void, false); + TEST_TR(returns_convertible_to_ret1, ret1, true); + TEST_TR(returns_convertible_to_ret2, ret2, true); + TEST_TR(Base1, bool, true); + TEST_TR(Derived1, bool, true); + TEST_TR(Base2, bool, false); + TEST_TR(Derived2, bool, true); +// compile time error +// TEST_T(internal_private, false); +} + +} + +#endif diff --git a/libs/type_traits/test/has_right_shift_assign_test.cpp b/libs/type_traits/test/has_right_shift_assign_test.cpp new file mode 100644 index 0000000000..1dbf91e09c --- /dev/null +++ b/libs/type_traits/test/has_right_shift_assign_test.cpp @@ -0,0 +1,228 @@ +// (C) Copyright 2009-2011 Frederic Bron. +// 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/has_right_shift_assign.hpp> +#endif + +#define BOOST_TT_TRAIT_NAME has_right_shift_assign +#define BOOST_TT_TRAIT_OP >>= + + +#include "has_binary_operators.hpp" + +void specific() { + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, void, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, int &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, double, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, void* const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, void, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, void, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, void, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, bool, bool & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, bool &, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int const, bool & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, double &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, double const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* const &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* const &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, bool const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int const, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, double const, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, double &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, double const &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, double const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, void* const &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, void* const &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int* >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int* const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, bool, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int const, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int const &, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, void* &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, void* &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int*, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int* const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, bool, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, bool &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, double const, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, double const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void* const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void* &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void* &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void* const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void* const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool const, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool &, int & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, double &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, void* const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, void* const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int* & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int* const &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, bool &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, bool &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, bool const &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int const, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, double const, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, double & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, double &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, void* const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, void* &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int*, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int* &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int* &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, bool &, int & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, bool const &, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, bool const &, int & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, int &, int & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, double, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, double, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, double const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, double const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, void* &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, int* &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int const, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int const &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, double, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, double const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, void* const, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, void* &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, void* &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int* &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int* const &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, bool const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, double, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, double const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, void* const, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, void* const &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, bool &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, bool const &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, double, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, void*, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, void* &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int* const &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, bool, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, bool const &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, double, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, double const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, double &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, double &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, double const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, void* const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, int*, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, void*, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, void* const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, void* const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int* const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int* &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int* &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, bool, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, bool const, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int* const, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int* const &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, int const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, double const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, void* const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, void* const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, bool const &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int const, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, double, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, double, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, double const, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, double const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, void* const, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int* const, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int* const, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int* const &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int* const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, bool, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, bool const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, bool const, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, double const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, void* &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, void* const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, double const &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, void*, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int* const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int* &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int* &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int* const &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, bool, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, double const, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, double &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, double const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, void* >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, int* const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, int* &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, double &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, void* const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int*, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int* const &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, double const, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, void*, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, void* const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int*, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int* const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int* &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int* const &, int const & >::value), 0); + +} + +TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME) + common(); + specific(); +TT_TEST_END diff --git a/libs/type_traits/test/has_right_shift_test.cpp b/libs/type_traits/test/has_right_shift_test.cpp new file mode 100644 index 0000000000..584c971395 --- /dev/null +++ b/libs/type_traits/test/has_right_shift_test.cpp @@ -0,0 +1,247 @@ +// (C) Copyright 2009-2011 Frederic Bron. +// 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/has_right_shift.hpp> +#endif + +#define BOOST_TT_TRAIT_NAME has_right_shift +#define BOOST_TT_TRAIT_OP >> + +#include <istream> +#include <string> + +#include "has_binary_operators.hpp" + +void specific() { + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, void, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, int &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, double, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, void* const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, void, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, void, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, void, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, bool, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, bool &, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, double &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, double const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* const &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* const &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, bool const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int const, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, double const, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, double &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, double const &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, double const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, void* const &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, void* const &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int* >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int* const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, bool, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int const, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int const &, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, void* &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, void* &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int*, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int* const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, bool, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, bool &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, double const, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, double const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void* const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void* &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void* &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void* const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void* const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool const, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, double &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, void* const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, void* const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int* & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int* const &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, bool &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, bool &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, bool const &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int const, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, double const, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, double & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, double &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, void* const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, void* &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int*, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int* &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int* &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, bool &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, bool const &, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, bool const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, int &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, double, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, double, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, double const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, double const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, void* &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, int* &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int const, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int const &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, double, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, double const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, void* const, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, void* &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, void* &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int* &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int* const &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, bool const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, double, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, double const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, void* const, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, void* const &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, bool &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, bool const &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, double, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, void*, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, void* &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int* const &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, bool, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, bool const &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, double, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, double const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, double &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, double &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, double const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, void* const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, int*, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, void*, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, void* const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, void* const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int* const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int* &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int* &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, bool, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, bool const, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int* const, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int* const &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, int const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, double const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, void* const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, void* const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, bool const &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int const, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, double, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, double, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, double const, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, double const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, void* const, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int* const, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int* const, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int* const &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int* const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, bool, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, bool const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, bool const, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, double const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, void* &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, void* const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, double const &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, void*, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int* const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int* &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int* &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int* const &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, bool, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, double const, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, double &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, double const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, void* >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, int* const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, int* &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, double &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, void* const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int*, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int* const &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, double const, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, void*, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, void* const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int*, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int* const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int* &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int* const &, int const & >::value), 0); + + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< std::istream, bool&, std::istream& >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< std::istream, short&, std::istream& >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< std::istream, unsigned short&, std::istream& >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< std::istream, int&, std::istream& >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< std::istream, unsigned int&, std::istream& >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< std::istream, long&, std::istream& >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< std::istream, unsigned long&, std::istream& >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< std::istream, float&, std::istream& >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< std::istream, double&, std::istream& >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< std::istream, void*&, std::istream& >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< std::istream, char&, std::istream& >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< std::istream, signed char&, std::istream& >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< std::istream, unsigned char&, std::istream& >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< std::istream, char*, std::istream& >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< std::istream, signed char*, std::istream& >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< std::istream, unsigned char*, std::istream& >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< std::istream, std::string&, std::istream& >::value), 1); +} + +TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME) + common(); + specific(); +TT_TEST_END diff --git a/libs/type_traits/test/has_trivial_assign_test.cpp b/libs/type_traits/test/has_trivial_assign_test.cpp new file mode 100644 index 0000000000..39b1716b69 --- /dev/null +++ b/libs/type_traits/test/has_trivial_assign_test.cpp @@ -0,0 +1,209 @@ + +// (C) Copyright John Maddock 2000. +// 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/has_trivial_assign.hpp> +#endif + +TT_TEST_BEGIN(has_trivial_assign) + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_assign<bool>::value, true); +#ifndef TEST_STD +// unspecified behaviour: +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_assign<bool const>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_assign<bool volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_assign<bool const volatile>::value, false); +#endif + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_assign<signed char>::value, true); +#ifndef TEST_STD +// unspecified behaviour: +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_assign<signed char const>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_assign<signed char volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_assign<signed char const volatile>::value, false); +#endif +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_assign<unsigned char>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_assign<char>::value, true); +#ifndef TEST_STD +// unspecified behaviour: +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_assign<unsigned char const>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_assign<char const>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_assign<unsigned char volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_assign<char volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_assign<unsigned char const volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_assign<char const volatile>::value, false); +#endif + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_assign<unsigned short>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_assign<short>::value, true); +#ifndef TEST_STD +// unspecified behaviour: +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_assign<unsigned short const>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_assign<short const>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_assign<unsigned short volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_assign<short volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_assign<unsigned short const volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_assign<short const volatile>::value, false); +#endif +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_assign<unsigned int>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_assign<int>::value, true); +#ifndef TEST_STD +// unspecified behaviour: +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_assign<unsigned int const>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_assign<int const>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_assign<unsigned int volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_assign<int volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_assign<unsigned int const volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_assign<int const volatile>::value, false); +#endif +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_assign<unsigned long>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_assign<long>::value, true); +#ifndef TEST_STD +// unspecified behaviour: +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_assign<unsigned long const>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_assign<long const>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_assign<unsigned long volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_assign<long volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_assign<unsigned long const volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_assign<long const volatile>::value, false); +#endif +#ifdef BOOST_HAS_LONG_LONG + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_assign< ::boost::ulong_long_type>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_assign< ::boost::long_long_type>::value, true); +#ifndef TEST_STD +// unspecified behaviour: +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_assign< ::boost::ulong_long_type const>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_assign< ::boost::long_long_type const>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_assign< ::boost::ulong_long_type volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_assign< ::boost::long_long_type volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_assign< ::boost::ulong_long_type const volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_assign< ::boost::long_long_type const volatile>::value, false); +#endif +#endif + +#ifdef BOOST_HAS_MS_INT64 + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_assign<unsigned __int8>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_assign<__int8>::value, true); +#ifndef TEST_STD +// unspecified behaviour: +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_assign<unsigned __int8 const>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_assign<__int8 const>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_assign<unsigned __int8 volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_assign<__int8 volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_assign<unsigned __int8 const volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_assign<__int8 const volatile>::value, false); +#endif +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_assign<unsigned __int16>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_assign<__int16>::value, true); +#ifndef TEST_STD +// unspecified behaviour: +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_assign<unsigned __int16 const>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_assign<__int16 const>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_assign<unsigned __int16 volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_assign<__int16 volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_assign<unsigned __int16 const volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_assign<__int16 const volatile>::value, false); +#endif +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_assign<unsigned __int32>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_assign<__int32>::value, true); +#ifndef TEST_STD +// unspecified behaviour: +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_assign<unsigned __int32 const>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_assign<__int32 const>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_assign<unsigned __int32 volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_assign<__int32 volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_assign<unsigned __int32 const volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_assign<__int32 const volatile>::value, false); +#endif +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_assign<unsigned __int64>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_assign<__int64>::value, true); +#ifndef TEST_STD +// unspecified behaviour: +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_assign<unsigned __int64 const>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_assign<__int64 const>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_assign<unsigned __int64 volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_assign<__int64 volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_assign<unsigned __int64 const volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_assign<__int64 const volatile>::value, false); +#endif +#endif + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_assign<float>::value, true); +#ifndef TEST_STD +// unspecified behaviour: +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_assign<float const>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_assign<float volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_assign<float const volatile>::value, false); +#endif +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_assign<double>::value, true); +#ifndef TEST_STD +// unspecified behaviour: +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_assign<double const>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_assign<double volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_assign<double const volatile>::value, false); +#endif +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_assign<long double>::value, true); +#ifndef TEST_STD +// unspecified behaviour: +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_assign<long double const>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_assign<long double volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_assign<long double const volatile>::value, false); +#endif + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_assign<int>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_assign<void*>::value, true); +#ifndef TEST_STD +// unspecified behaviour: +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_assign<int*const>::value, false); +#endif +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_assign<f1>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_assign<f2>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_assign<f3>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_assign<mf1>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_assign<mf2>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_assign<mf3>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_assign<mp>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_assign<cmf>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_assign<enum_UDT>::value, true); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_assign<int&>::value, false); +#ifndef BOOST_NO_RVALUE_REFERENCES +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_assign<int&&>::value, false); +#endif +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_assign<const int&>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_assign<int[2]>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_assign<int[3][2]>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_assign<int[2][4][5][6][3]>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_assign<UDT>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_assign<empty_UDT>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_assign<void>::value, false); +// cases we would like to succeed but can't implement in the language: +BOOST_CHECK_SOFT_INTEGRAL_CONSTANT(::tt::has_trivial_assign<empty_POD_UDT>::value, true, false); +BOOST_CHECK_SOFT_INTEGRAL_CONSTANT(::tt::has_trivial_assign<POD_UDT>::value, true, false); +BOOST_CHECK_SOFT_INTEGRAL_CONSTANT(::tt::has_trivial_assign<POD_union_UDT>::value, true, false); +BOOST_CHECK_SOFT_INTEGRAL_CONSTANT(::tt::has_trivial_assign<empty_POD_union_UDT>::value, true, false); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_assign<trivial_except_assign>::value, false); +BOOST_CHECK_SOFT_INTEGRAL_CONSTANT(::tt::has_trivial_assign<trivial_except_destroy>::value, true, false); +BOOST_CHECK_SOFT_INTEGRAL_CONSTANT(::tt::has_trivial_assign<trivial_except_construct>::value, true, false); +BOOST_CHECK_SOFT_INTEGRAL_CONSTANT(::tt::has_trivial_assign<trivial_except_copy>::value, true, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_assign<wrap<trivial_except_assign> >::value, false); +BOOST_CHECK_SOFT_INTEGRAL_CONSTANT(::tt::has_trivial_assign<wrap<trivial_except_destroy> >::value, true, false); +BOOST_CHECK_SOFT_INTEGRAL_CONSTANT(::tt::has_trivial_assign<wrap<trivial_except_construct> >::value, true, false); +BOOST_CHECK_SOFT_INTEGRAL_CONSTANT(::tt::has_trivial_assign<wrap<trivial_except_copy> >::value, true, false); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_assign<test_abc1>::value, false); + +TT_TEST_END + + + diff --git a/libs/type_traits/test/has_trivial_constr_test.cpp b/libs/type_traits/test/has_trivial_constr_test.cpp new file mode 100644 index 0000000000..cc2d4c00c8 --- /dev/null +++ b/libs/type_traits/test/has_trivial_constr_test.cpp @@ -0,0 +1,181 @@ + +// (C) Copyright John Maddock 2000. +// 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/has_trivial_constructor.hpp> +#endif + +TT_TEST_BEGIN(has_trivial_constructor) + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_constructor<bool>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_constructor<bool const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_constructor<bool volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_constructor<bool const volatile>::value, true); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_constructor<signed char>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_constructor<signed char const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_constructor<signed char volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_constructor<signed char const volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_constructor<unsigned char>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_constructor<char>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_constructor<unsigned char const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_constructor<char const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_constructor<unsigned char volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_constructor<char volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_constructor<unsigned char const volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_constructor<char const volatile>::value, true); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_constructor<unsigned short>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_constructor<short>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_constructor<unsigned short const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_constructor<short const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_constructor<unsigned short volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_constructor<short volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_constructor<unsigned short const volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_constructor<short const volatile>::value, true); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_constructor<unsigned int>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_constructor<int>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_constructor<unsigned int const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_constructor<int const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_constructor<unsigned int volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_constructor<int volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_constructor<unsigned int const volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_constructor<int const volatile>::value, true); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_constructor<unsigned long>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_constructor<long>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_constructor<unsigned long const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_constructor<long const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_constructor<unsigned long volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_constructor<long volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_constructor<unsigned long const volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_constructor<long const volatile>::value, true); + +#ifdef BOOST_HAS_LONG_LONG + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_constructor< ::boost::ulong_long_type>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_constructor< ::boost::long_long_type>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_constructor< ::boost::ulong_long_type const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_constructor< ::boost::long_long_type const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_constructor< ::boost::ulong_long_type volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_constructor< ::boost::long_long_type volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_constructor< ::boost::ulong_long_type const volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_constructor< ::boost::long_long_type const volatile>::value, true); + +#endif + +#ifdef BOOST_HAS_MS_INT64 + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_constructor<unsigned __int8>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_constructor<__int8>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_constructor<unsigned __int8 const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_constructor<__int8 const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_constructor<unsigned __int8 volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_constructor<__int8 volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_constructor<unsigned __int8 const volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_constructor<__int8 const volatile>::value, true); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_constructor<unsigned __int16>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_constructor<__int16>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_constructor<unsigned __int16 const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_constructor<__int16 const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_constructor<unsigned __int16 volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_constructor<__int16 volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_constructor<unsigned __int16 const volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_constructor<__int16 const volatile>::value, true); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_constructor<unsigned __int32>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_constructor<__int32>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_constructor<unsigned __int32 const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_constructor<__int32 const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_constructor<unsigned __int32 volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_constructor<__int32 volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_constructor<unsigned __int32 const volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_constructor<__int32 const volatile>::value, true); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_constructor<unsigned __int64>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_constructor<__int64>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_constructor<unsigned __int64 const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_constructor<__int64 const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_constructor<unsigned __int64 volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_constructor<__int64 volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_constructor<unsigned __int64 const volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_constructor<__int64 const volatile>::value, true); + +#endif + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_constructor<float>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_constructor<float const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_constructor<float volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_constructor<float const volatile>::value, true); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_constructor<double>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_constructor<double const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_constructor<double volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_constructor<double const volatile>::value, true); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_constructor<long double>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_constructor<long double const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_constructor<long double volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_constructor<long double const volatile>::value, true); + + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_constructor<int>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_constructor<void*>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_constructor<int*const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_constructor<f1>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_constructor<f2>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_constructor<f3>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_constructor<mf1>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_constructor<mf2>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_constructor<mf3>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_constructor<mp>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_constructor<cmf>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_constructor<enum_UDT>::value, true); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_constructor<int&>::value, false); +#ifndef BOOST_NO_RVALUE_REFERENCES +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_constructor<int&&>::value, false); +#endif +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_constructor<const int&>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_constructor<int[2]>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_constructor<int[3][2]>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_constructor<int[2][4][5][6][3]>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_constructor<UDT>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_constructor<empty_UDT>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_constructor<void>::value, true); +// cases we would like to succeed but can't implement in the language: +BOOST_CHECK_SOFT_INTEGRAL_CONSTANT(::tt::has_trivial_constructor<empty_POD_UDT>::value, true, false); +BOOST_CHECK_SOFT_INTEGRAL_CONSTANT(::tt::has_trivial_constructor<POD_UDT>::value, true, false); +BOOST_CHECK_SOFT_INTEGRAL_CONSTANT(::tt::has_trivial_constructor<POD_union_UDT>::value, true, false); +BOOST_CHECK_SOFT_INTEGRAL_CONSTANT(::tt::has_trivial_constructor<empty_POD_union_UDT>::value, true, false); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_constructor<trivial_except_construct>::value, false); +BOOST_CHECK_SOFT_INTEGRAL_CONSTANT(::tt::has_trivial_constructor<trivial_except_destroy>::value, true, false); +BOOST_CHECK_SOFT_INTEGRAL_CONSTANT(::tt::has_trivial_constructor<trivial_except_assign>::value, true, false); +//BOOST_CHECK_SOFT_INTEGRAL_CONSTANT(::tt::has_trivial_constructor<trivial_except_copy>::value, true, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_constructor<wrap<trivial_except_construct> >::value, false); +BOOST_CHECK_SOFT_INTEGRAL_CONSTANT(::tt::has_trivial_constructor<wrap<trivial_except_destroy> >::value, true, false); +BOOST_CHECK_SOFT_INTEGRAL_CONSTANT(::tt::has_trivial_constructor<wrap<trivial_except_assign> >::value, true, false); +//BOOST_CHECK_SOFT_INTEGRAL_CONSTANT(::tt::has_trivial_constructor<wrap<trivial_except_copy> >::value, true, false); + + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_constructor<test_abc1>::value, false); + +TT_TEST_END + + + + + + + + diff --git a/libs/type_traits/test/has_trivial_copy_test.cpp b/libs/type_traits/test/has_trivial_copy_test.cpp new file mode 100644 index 0000000000..85e9d0dcc4 --- /dev/null +++ b/libs/type_traits/test/has_trivial_copy_test.cpp @@ -0,0 +1,214 @@ + +// (C) Copyright John Maddock 2000. +// 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/has_trivial_copy.hpp> +#endif + +TT_TEST_BEGIN(has_trivial_copy) + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_copy<bool>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_copy<bool const>::value, true); +#ifndef TEST_STD +// unspecified behaviour: +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_copy<bool volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_copy<bool const volatile>::value, false); +#endif + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_copy<signed char>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_copy<signed char const>::value, true); +#ifndef TEST_STD +// unspecified behaviour: +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_copy<signed char volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_copy<signed char const volatile>::value, false); +#endif +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_copy<unsigned char>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_copy<char>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_copy<unsigned char const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_copy<char const>::value, true); +#ifndef TEST_STD +// unspecified behaviour: +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_copy<unsigned char volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_copy<char volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_copy<unsigned char const volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_copy<char const volatile>::value, false); +#endif + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_copy<unsigned short>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_copy<short>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_copy<unsigned short const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_copy<short const>::value, true); +#ifndef TEST_STD +// unspecified behaviour: +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_copy<unsigned short volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_copy<short volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_copy<unsigned short const volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_copy<short const volatile>::value, false); +#endif + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_copy<unsigned int>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_copy<int>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_copy<unsigned int const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_copy<int const>::value, true); +#ifndef TEST_STD +// unspecified behaviour: +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_copy<unsigned int volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_copy<int volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_copy<unsigned int const volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_copy<int const volatile>::value, false); +#endif + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_copy<unsigned long>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_copy<long>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_copy<unsigned long const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_copy<long const>::value, true); +#ifndef TEST_STD +// unspecified behaviour: +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_copy<unsigned long volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_copy<long volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_copy<unsigned long const volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_copy<long const volatile>::value, false); +#endif +#ifdef BOOST_HAS_LONG_LONG + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_copy< ::boost::ulong_long_type>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_copy< ::boost::long_long_type>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_copy< ::boost::ulong_long_type const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_copy< ::boost::long_long_type const>::value, true); +#ifndef TEST_STD +// unspecified behaviour: +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_copy< ::boost::ulong_long_type volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_copy< ::boost::long_long_type volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_copy< ::boost::ulong_long_type const volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_copy< ::boost::long_long_type const volatile>::value, false); +#endif +#endif + +#ifdef BOOST_HAS_MS_INT64 + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_copy<unsigned __int8>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_copy<__int8>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_copy<unsigned __int8 const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_copy<__int8 const>::value, true); +#ifndef TEST_STD +// unspecified behaviour: +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_copy<unsigned __int8 volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_copy<__int8 volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_copy<unsigned __int8 const volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_copy<__int8 const volatile>::value, false); +#endif +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_copy<unsigned __int16>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_copy<__int16>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_copy<unsigned __int16 const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_copy<__int16 const>::value, true); +#ifndef TEST_STD +// unspecified behaviour: +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_copy<unsigned __int16 volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_copy<__int16 volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_copy<unsigned __int16 const volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_copy<__int16 const volatile>::value, false); +#endif +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_copy<unsigned __int32>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_copy<__int32>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_copy<unsigned __int32 const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_copy<__int32 const>::value, true); +#ifndef TEST_STD +// unspecified behaviour: +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_copy<unsigned __int32 volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_copy<__int32 volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_copy<unsigned __int32 const volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_copy<__int32 const volatile>::value, false); +#endif +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_copy<unsigned __int64>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_copy<__int64>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_copy<unsigned __int64 const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_copy<__int64 const>::value, true); +#ifndef TEST_STD +// unspecified behaviour: +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_copy<unsigned __int64 volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_copy<__int64 volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_copy<unsigned __int64 const volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_copy<__int64 const volatile>::value, false); +#endif +#endif + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_copy<float>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_copy<float const>::value, true); +#ifndef TEST_STD +// unspecified behaviour: +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_copy<float volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_copy<float const volatile>::value, false); +#endif + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_copy<double>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_copy<double const>::value, true); +#ifndef TEST_STD +// unspecified behaviour: +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_copy<double volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_copy<double const volatile>::value, false); +#endif + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_copy<long double>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_copy<long double const>::value, true); +#ifndef TEST_STD +// unspecified behaviour: +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_copy<long double volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_copy<long double const volatile>::value, false); +#endif + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_copy<int>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_copy<void*>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_copy<int*const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_copy<f1>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_copy<f2>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_copy<f3>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_copy<mf1>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_copy<mf2>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_copy<mf3>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_copy<mp>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_copy<cmf>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_copy<enum_UDT>::value, true); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_copy<int&>::value, false); +#ifndef BOOST_NO_RVALUE_REFERENCES +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_copy<int&&>::value, false); +#endif +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_copy<const int&>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_copy<int[2]>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_copy<int[3][2]>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_copy<int[2][4][5][6][3]>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_copy<UDT>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_copy<void>::value, false); +// cases we would like to succeed but can't implement in the language: +BOOST_CHECK_SOFT_INTEGRAL_CONSTANT(::tt::has_trivial_copy<empty_POD_UDT>::value, true, false); +BOOST_CHECK_SOFT_INTEGRAL_CONSTANT(::tt::has_trivial_copy<POD_UDT>::value, true, false); +BOOST_CHECK_SOFT_INTEGRAL_CONSTANT(::tt::has_trivial_copy<POD_union_UDT>::value, true, false); +BOOST_CHECK_SOFT_INTEGRAL_CONSTANT(::tt::has_trivial_copy<empty_POD_union_UDT>::value, true, false); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_copy<trivial_except_copy>::value, false); +BOOST_CHECK_SOFT_INTEGRAL_CONSTANT(::tt::has_trivial_copy<trivial_except_destroy>::value, true, false); +BOOST_CHECK_SOFT_INTEGRAL_CONSTANT(::tt::has_trivial_copy<trivial_except_construct>::value, true, false); +BOOST_CHECK_SOFT_INTEGRAL_CONSTANT(::tt::has_trivial_copy<trivial_except_assign>::value, true, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_copy<wrap<trivial_except_copy> >::value, false); +BOOST_CHECK_SOFT_INTEGRAL_CONSTANT(::tt::has_trivial_copy<wrap<trivial_except_destroy> >::value, true, false); +BOOST_CHECK_SOFT_INTEGRAL_CONSTANT(::tt::has_trivial_copy<wrap<trivial_except_construct> >::value, true, false); +BOOST_CHECK_SOFT_INTEGRAL_CONSTANT(::tt::has_trivial_copy<wrap<trivial_except_assign> >::value, true, false); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_copy<test_abc1>::value, false); + +TT_TEST_END + + + + + + + + diff --git a/libs/type_traits/test/has_trivial_destructor_test.cpp b/libs/type_traits/test/has_trivial_destructor_test.cpp new file mode 100644 index 0000000000..a2f1632cab --- /dev/null +++ b/libs/type_traits/test/has_trivial_destructor_test.cpp @@ -0,0 +1,176 @@ + +// (C) Copyright John Maddock 2000. +// 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/has_trivial_destructor.hpp> +#endif + +TT_TEST_BEGIN(has_trivial_destructor) + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_destructor<bool>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_destructor<bool const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_destructor<bool volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_destructor<bool const volatile>::value, true); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_destructor<signed char>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_destructor<signed char const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_destructor<signed char volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_destructor<signed char const volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_destructor<unsigned char>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_destructor<char>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_destructor<unsigned char const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_destructor<char const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_destructor<unsigned char volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_destructor<char volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_destructor<unsigned char const volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_destructor<char const volatile>::value, true); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_destructor<unsigned short>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_destructor<short>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_destructor<unsigned short const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_destructor<short const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_destructor<unsigned short volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_destructor<short volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_destructor<unsigned short const volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_destructor<short const volatile>::value, true); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_destructor<unsigned int>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_destructor<int>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_destructor<unsigned int const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_destructor<int const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_destructor<unsigned int volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_destructor<int volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_destructor<unsigned int const volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_destructor<int const volatile>::value, true); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_destructor<unsigned long>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_destructor<long>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_destructor<unsigned long const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_destructor<long const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_destructor<unsigned long volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_destructor<long volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_destructor<unsigned long const volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_destructor<long const volatile>::value, true); + +#ifdef BOOST_HAS_LONG_LONG + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_destructor< ::boost::ulong_long_type>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_destructor< ::boost::long_long_type>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_destructor< ::boost::ulong_long_type const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_destructor< ::boost::long_long_type const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_destructor< ::boost::ulong_long_type volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_destructor< ::boost::long_long_type volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_destructor< ::boost::ulong_long_type const volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_destructor< ::boost::long_long_type const volatile>::value, true); + +#endif + +#ifdef BOOST_HAS_MS_INT64 + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_destructor<unsigned __int8>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_destructor<__int8>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_destructor<unsigned __int8 const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_destructor<__int8 const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_destructor<unsigned __int8 volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_destructor<__int8 volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_destructor<unsigned __int8 const volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_destructor<__int8 const volatile>::value, true); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_destructor<unsigned __int16>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_destructor<__int16>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_destructor<unsigned __int16 const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_destructor<__int16 const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_destructor<unsigned __int16 volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_destructor<__int16 volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_destructor<unsigned __int16 const volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_destructor<__int16 const volatile>::value, true); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_destructor<unsigned __int32>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_destructor<__int32>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_destructor<unsigned __int32 const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_destructor<__int32 const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_destructor<unsigned __int32 volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_destructor<__int32 volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_destructor<unsigned __int32 const volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_destructor<__int32 const volatile>::value, true); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_destructor<unsigned __int64>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_destructor<__int64>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_destructor<unsigned __int64 const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_destructor<__int64 const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_destructor<unsigned __int64 volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_destructor<__int64 volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_destructor<unsigned __int64 const volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_destructor<__int64 const volatile>::value, true); + +#endif + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_destructor<float>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_destructor<float const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_destructor<float volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_destructor<float const volatile>::value, true); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_destructor<double>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_destructor<double const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_destructor<double volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_destructor<double const volatile>::value, true); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_destructor<long double>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_destructor<long double const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_destructor<long double volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_destructor<long double const volatile>::value, true); + + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_destructor<int>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_destructor<void*>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_destructor<int*const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_destructor<f1>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_destructor<f2>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_destructor<f3>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_destructor<mf1>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_destructor<mf2>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_destructor<mf3>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_destructor<mp>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_destructor<cmf>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_destructor<enum_UDT>::value, true); + +// +// These are commented out for now because it's not clear what the semantics should be: +// on the one hand references always have trivial destructors (in the sence that there is +// nothing to destruct), on the other hand the thing referenced may not have a trivial +// destructor, it really depends upon the users code as to what should happen here: +// +//BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_destructor<int&>::value, false); +//BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_destructor<const int&>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_destructor<int[2]>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_destructor<int[3][2]>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_destructor<int[2][4][5][6][3]>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_destructor<UDT>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_destructor<empty_UDT>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_destructor<void>::value, false); +// cases we would like to succeed but can't implement in the language: +BOOST_CHECK_SOFT_INTEGRAL_CONSTANT(::tt::has_trivial_destructor<empty_POD_UDT>::value, true, false); +BOOST_CHECK_SOFT_INTEGRAL_CONSTANT(::tt::has_trivial_destructor<POD_UDT>::value, true, false); +BOOST_CHECK_SOFT_INTEGRAL_CONSTANT(::tt::has_trivial_destructor<POD_union_UDT>::value, true, false); +BOOST_CHECK_SOFT_INTEGRAL_CONSTANT(::tt::has_trivial_destructor<empty_POD_union_UDT>::value, true, false); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_destructor<trivial_except_destroy>::value, false); +BOOST_CHECK_SOFT_INTEGRAL_CONSTANT(::tt::has_trivial_destructor<trivial_except_copy>::value, true, false); +BOOST_CHECK_SOFT_INTEGRAL_CONSTANT(::tt::has_trivial_destructor<trivial_except_construct>::value, true, false); +BOOST_CHECK_SOFT_INTEGRAL_CONSTANT(::tt::has_trivial_destructor<trivial_except_assign>::value, true, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_destructor<wrap<trivial_except_destroy> >::value, false); +BOOST_CHECK_SOFT_INTEGRAL_CONSTANT(::tt::has_trivial_destructor<wrap<trivial_except_copy> >::value, true, false); +BOOST_CHECK_SOFT_INTEGRAL_CONSTANT(::tt::has_trivial_destructor<wrap<trivial_except_construct> >::value, true, false); +BOOST_CHECK_SOFT_INTEGRAL_CONSTANT(::tt::has_trivial_destructor<wrap<trivial_except_assign> >::value, true, false); + +TT_TEST_END + + + diff --git a/libs/type_traits/test/has_unary_minus_test.cpp b/libs/type_traits/test/has_unary_minus_test.cpp new file mode 100644 index 0000000000..94ac223ac6 --- /dev/null +++ b/libs/type_traits/test/has_unary_minus_test.cpp @@ -0,0 +1,228 @@ +// (C) Copyright 2009-2011 Frederic Bron. +// 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/has_unary_minus.hpp> +#endif + +#define BOOST_TT_TRAIT_NAME has_unary_minus +#define BOOST_TT_TRAIT_OP - + + +#include "has_prefix_operators.hpp" + +void specific() { + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int const & >::value), 0); + +} + +TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME) + common(); + specific(); +TT_TEST_END diff --git a/libs/type_traits/test/has_unary_plus_test.cpp b/libs/type_traits/test/has_unary_plus_test.cpp new file mode 100644 index 0000000000..208b43c70d --- /dev/null +++ b/libs/type_traits/test/has_unary_plus_test.cpp @@ -0,0 +1,228 @@ +// (C) Copyright 2009-2011 Frederic Bron. +// 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/has_unary_plus.hpp> +#endif + +#define BOOST_TT_TRAIT_NAME has_unary_plus +#define BOOST_TT_TRAIT_OP + + + +#include "has_prefix_operators.hpp" + +void specific() { + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, bool >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, bool const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, bool const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int const & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, void >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool const >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool const & >::value), 1); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int const >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int & >::value), 0); + BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int const & >::value), 0); + +} + +TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME) + common(); + specific(); +TT_TEST_END diff --git a/libs/type_traits/test/has_virtual_destructor_test.cpp b/libs/type_traits/test/has_virtual_destructor_test.cpp new file mode 100644 index 0000000000..ea5f3231a3 --- /dev/null +++ b/libs/type_traits/test/has_virtual_destructor_test.cpp @@ -0,0 +1,75 @@ + +// (C) Copyright John Maddock 2005. +// 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/has_virtual_destructor.hpp> +#endif + +#include <iostream> +#include <stdexcept> +#include <new> + +class polymorphic_no_virtual_destructor +{ +public: + virtual void method() = 0; +}; + +TT_TEST_BEGIN(has_virtual_destructor) + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_virtual_destructor<int>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_virtual_destructor<const int>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_virtual_destructor<volatile int>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_virtual_destructor<int*>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_virtual_destructor<int* const>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_virtual_destructor<int[2]>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_virtual_destructor<int&>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_virtual_destructor<mf4>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_virtual_destructor<f1>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_virtual_destructor<enum_UDT>::value, false); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_virtual_destructor<UDT>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_virtual_destructor<empty_UDT>::value, false); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_virtual_destructor<UDT*>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_virtual_destructor<UDT[2]>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_virtual_destructor<UDT&>::value, false); +#ifndef BOOST_NO_RVALUE_REFERENCES +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_virtual_destructor<UDT&&>::value, false); +#endif +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_virtual_destructor<void>::value, false); + +BOOST_CHECK_SOFT_INTEGRAL_CONSTANT(::tt::has_virtual_destructor<VB>::value, true, false); +BOOST_CHECK_SOFT_INTEGRAL_CONSTANT(::tt::has_virtual_destructor<VD>::value, true, false); +BOOST_CHECK_SOFT_INTEGRAL_CONSTANT(::tt::has_virtual_destructor<test_abc1>::value, true, false); +BOOST_CHECK_SOFT_INTEGRAL_CONSTANT(::tt::has_virtual_destructor<test_abc2>::value, true, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_virtual_destructor<polymorphic_no_virtual_destructor>::value, false); +#ifndef BOOST_NO_STD_LOCALE +BOOST_CHECK_SOFT_INTEGRAL_CONSTANT(::tt::has_virtual_destructor<std::iostream>::value, true, false); +BOOST_CHECK_SOFT_INTEGRAL_CONSTANT(::tt::has_virtual_destructor<std::basic_streambuf<char> >::value, true, false); +BOOST_CHECK_SOFT_INTEGRAL_CONSTANT(::tt::has_virtual_destructor<std::basic_ios<char> >::value, true, false); +BOOST_CHECK_SOFT_INTEGRAL_CONSTANT(::tt::has_virtual_destructor<std::basic_istream<char> >::value, true, false); +BOOST_CHECK_SOFT_INTEGRAL_CONSTANT(::tt::has_virtual_destructor<std::basic_streambuf<char> >::value, true, false); +#endif +BOOST_CHECK_SOFT_INTEGRAL_CONSTANT(::tt::has_virtual_destructor<std::exception>::value, true, false); +BOOST_CHECK_SOFT_INTEGRAL_CONSTANT(::tt::has_virtual_destructor<std::bad_alloc>::value, true, false); +BOOST_CHECK_SOFT_INTEGRAL_CONSTANT(::tt::has_virtual_destructor<std::runtime_error>::value, true, false); +BOOST_CHECK_SOFT_INTEGRAL_CONSTANT(::tt::has_virtual_destructor<std::out_of_range>::value, true, false); +BOOST_CHECK_SOFT_INTEGRAL_CONSTANT(::tt::has_virtual_destructor<std::range_error>::value, true, false); + +TT_TEST_END + + + + + + + + diff --git a/libs/type_traits/test/init.cpp b/libs/type_traits/test/init.cpp new file mode 100644 index 0000000000..95a5a9f77d --- /dev/null +++ b/libs/type_traits/test/init.cpp @@ -0,0 +1,23 @@ + +// (C) Copyright John Maddock 2000. +// 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" + +boost::unit_test::test_suite* get_master_unit(const char* name) +{ + static boost::unit_test::test_suite* ptest_suite = 0; + if(0 == ptest_suite) + ptest_suite = BOOST_TEST_SUITE( name ? name : "" ); + return ptest_suite; +} + +boost::unit_test::test_suite* init_unit_test_suite ( int , char* [] ) +{ + return get_master_unit(); +} + + + diff --git a/libs/type_traits/test/is_abstract_test.cpp b/libs/type_traits/test/is_abstract_test.cpp new file mode 100644 index 0000000000..17c7bd2d76 --- /dev/null +++ b/libs/type_traits/test/is_abstract_test.cpp @@ -0,0 +1,445 @@ + +// (C) Copyright Rani Sharoni,Robert Ramey, Pavel Vozenilek and Christoph Ludwig 2004. +// 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_abstract.hpp> +#endif + +#ifdef BOOST_MSVC +#pragma warning(disable: 4505) +#endif + + +struct TestA {}; +struct TestB { virtual void foo(void) = 0; }; +struct TestC { private: virtual void foo(void) = 0; }; +struct TestD : public TestA {}; +struct TestE : public TestB {}; +struct TestF : public TestC {}; +struct TestG : public TestB { virtual void foo(void) {} }; +struct TestH : public TestC { private: virtual void foo(void) {} }; +struct TestI : public TestB, public TestC {}; +struct TestJ : public TestI { virtual void foo(void) {} }; +struct TestK : public TestB { virtual void foo(void); virtual void foo2(void) = 0; }; +struct TestL : public TestK { virtual void foo2(void) {} }; +struct TestM : public virtual TestB {}; +struct TestN : public virtual TestC {}; +struct TestO : public TestM, public TestN {}; +struct TestP : public TestO { virtual void foo(void) {} }; +struct TestQ : public TestB { virtual void foo(void) = 0; }; +struct TestR : public TestC { private: virtual void foo(void) = 0; }; +struct TestS { virtual void foo(void) {} }; +struct TestT { virtual ~TestT(void) {} virtual void foo(void) {} }; +struct TestU : public TestT { virtual void foo(void) = 0; }; +struct TestV : public TestT { virtual void foo(void) {} }; +struct TestW { virtual void foo1(void) = 0; virtual void foo2(void) = 0; }; +struct TestX : public TestW { virtual void foo1(void) {} virtual void foo2(void) {} }; +struct TestY { virtual ~TestY(void) = 0; }; +struct TestZ { virtual ~TestZ(void) = 0; }; TestZ::~TestZ(void) {} +struct TestAA : public TestZ { virtual ~TestAA(void) = 0; }; TestAA::~TestAA(void) {} +struct TestAB : public TestAA { virtual ~TestAB(void) {} }; +struct TestAC { virtual void foo(void) = 0; }; void TestAC::foo(void) {} +struct TestAD : public TestAC {}; +struct TestAE : public TestAD { virtual void foo() {} }; +struct TestAF : public TestAD { virtual void foo(); }; void TestAF::foo(void) {} +struct TestAG : public virtual TestA {}; + +// template test types: +template <class T> struct TTestA {}; +template <class T> struct TTestB { virtual void foo(void) = 0; }; +template <class T> struct TTestC { private: virtual void foo(void) = 0; }; +template <class T> struct TTestD : public TTestA<T> {}; +template <class T> struct TTestE : public TTestB<T> {}; +template <class T> struct TTestF : public TTestC<T> {}; +template <class T> struct TTestG : public TTestB<T> { virtual void foo(void) {} }; +template <class T> struct TTestH : public TTestC<T> { private: virtual void foo(void) {} }; +template <class T> struct TTestI : public TTestB<T>, public TTestC<T> {}; +template <class T> struct TTestJ : public TTestI<T> { virtual void foo(void) {} }; +template <class T> struct TTestK : public TTestB<T> { virtual void foo(void); virtual void foo2(void) = 0; }; +template <class T> struct TTestL : public TTestK<T> { virtual void foo2(void) {} }; +template <class T> struct TTestM : public virtual TTestB<T> {}; +template <class T> struct TTestN : public virtual TTestC<T> {}; +template <class T> struct TTestO : public TTestM<T>, public TTestN<T> {}; +template <class T> struct TTestP : public TTestO<T> { virtual void foo(void) {} }; +template <class T> struct TTestQ : public TTestB<T> { virtual void foo(void) = 0; }; +template <class T> struct TTestR : public TTestC<T> { private: virtual void foo(void) = 0; }; +template <class T> struct TTestS { virtual void foo(void) {} }; +template <class T> struct TTestT { virtual ~TTestT(void) {} virtual void foo(void) {} }; +template <class T> struct TTestU : public TTestT<T> { virtual void foo(void) = 0; }; +template <class T> struct TTestV : public TTestT<T> { virtual void foo(void) {} }; +template <class T> struct TTestW { virtual void foo1(void) = 0; virtual void foo2(void) = 0; }; +template <class T> struct TTestX : public TTestW<T> { virtual void foo1(void) {} virtual void foo2(void) {} }; +template <class T> struct TTestY { virtual ~TTestY(void) = 0; }; +template <class T> struct TTestZ { virtual ~TTestZ(void) = 0; }; template <class T> TTestZ<T>::~TTestZ(void) {} +template <class T> struct TTestAA : public TTestZ<T> { virtual ~TTestAA(void) = 0; }; template <class T> TTestAA<T>::~TTestAA(void) {} +template <class T> struct TTestAB : public TTestAA<T> { virtual ~TTestAB(void) {} }; +template <class T> struct TTestAC { virtual void foo(void) = 0; }; template <class T> void TTestAC<T>::foo(void) {} +template <class T> struct TTestAD : public TTestAC<T> {}; +template <class T> struct TTestAE : public TTestAD<T> { virtual void foo() {} }; +template <class T> struct TTestAF : public TTestAD<T> { virtual void foo(); }; template <class T> void TTestAF<T>::foo(void) {} +template <class T> struct TTestAG : public virtual TTestA<T> {}; + + +TT_TEST_BEGIN(is_abstract) + +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TestA>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TestB>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TestC>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TestD>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TestE>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TestF>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TestG>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TestH>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TestI>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TestJ>::value), false); // only one method implemented! +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TestK>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TestL>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TestM>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TestN>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TestO>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TestP>::value), false); // ??? +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TestQ>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TestR>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TestS>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TestT>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TestU>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TestV>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TestW>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TestX>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TestY>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TestZ>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TestAA>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TestAB>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TestAC>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TestAD>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TestAE>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TestAF>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TestAG>::value), false); + +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<const TestA>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<const TestB>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<const TestC>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<const TestD>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<const TestE>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<const TestF>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<const TestG>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<const TestH>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<const TestI>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<const TestJ>::value), false); // only one method implemented! +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<const TestK>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<const TestL>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<const TestM>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<const TestN>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<const TestO>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<const TestP>::value), false); // ??? +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<const TestQ>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<const TestR>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<const TestS>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<const TestT>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<const TestU>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<const TestV>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<const TestW>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<const TestX>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<const TestY>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<const TestZ>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<const TestAA>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<const TestAB>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<const TestAC>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<const TestAD>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<const TestAE>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<const TestAF>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<const TestAG>::value), false); + +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile TestA>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile TestB>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile TestC>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile TestD>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile TestE>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile TestF>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile TestG>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile TestH>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile TestI>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile TestJ>::value), false); // only one method implemented! +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile TestK>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile TestL>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile TestM>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile TestN>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile TestO>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile TestP>::value), false); // ??? +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile TestQ>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile TestR>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile TestS>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile TestT>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile TestU>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile TestV>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile TestW>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile TestX>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile TestY>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile TestZ>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile TestAA>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile TestAB>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile TestAC>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile TestAD>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile TestAE>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile TestAF>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile TestAG>::value), false); + +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile const TestA>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile const TestB>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile const TestC>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile const TestD>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile const TestE>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile const TestF>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile const TestG>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile const TestH>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile const TestI>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile const TestJ>::value), false); // only one method implemented! +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile const TestK>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile const TestL>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile const TestM>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile const TestN>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile const TestO>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile const TestP>::value), false); // ??? +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile const TestQ>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile const TestR>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile const TestS>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile const TestT>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile const TestU>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile const TestV>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile const TestW>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile const TestX>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile const TestY>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile const TestZ>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile const TestAA>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile const TestAB>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile const TestAC>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile const TestAD>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile const TestAE>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile const TestAF>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile const TestAG>::value), false); + +#ifndef BOOST_NO_RVALUE_REFERENCES +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TestA&&>::value), false); +#endif +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TestA&>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TestB&>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TestC&>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TestD&>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TestE&>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TestF&>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TestG&>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TestH&>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TestI&>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TestJ&>::value), false); // only one method implemented! +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TestK&>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TestL&>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TestM&>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TestN&>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TestO&>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TestP&>::value), false); // ??? +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TestQ&>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TestR&>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TestS&>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TestT&>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TestU&>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TestV&>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TestW&>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TestX&>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TestY&>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TestZ&>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TestAA&>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TestAB&>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TestAC&>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TestAD&>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TestAE&>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TestAF&>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TestAG&>::value), false); +#if !(defined(BOOST_MSVC) && (BOOST_MSVC < 1310)) +// MSVC prior to VC7.1 always runs out of swap space trying to +// compile these, so leave them out for now (the test fails anyway). +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TTestA<int> >::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TTestB<int> >::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TTestC<int> >::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TTestD<int> >::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TTestE<int> >::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TTestF<int> >::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TTestG<int> >::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TTestH<int> >::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TTestI<int> >::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TTestJ<int> >::value), false); // only one method implemented! +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TTestK<int> >::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TTestL<int> >::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TTestM<int> >::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TTestN<int> >::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TTestO<int> >::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TTestP<int> >::value), false); // ??? +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TTestQ<int> >::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TTestR<int> >::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TTestS<int> >::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TTestT<int> >::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TTestU<int> >::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TTestV<int> >::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TTestW<int> >::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TTestX<int> >::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TTestY<int> >::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TTestZ<int> >::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TTestAA<int> >::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TTestAB<int> >::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TTestAC<int> >::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TTestAD<int> >::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TTestAE<int> >::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TTestAF<int> >::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TTestAG<int> >::value), false); + +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<const TTestA<int> >::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<const TTestB<int> >::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<const TTestC<int> >::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<const TTestD<int> >::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<const TTestE<int> >::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<const TTestF<int> >::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<const TTestG<int> >::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<const TTestH<int> >::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<const TTestI<int> >::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<const TTestJ<int> >::value), false); // only one method implemented! +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<const TTestK<int> >::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<const TTestL<int> >::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<const TTestM<int> >::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<const TTestN<int> >::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<const TTestO<int> >::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<const TTestP<int> >::value), false); // ??? +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<const TTestQ<int> >::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<const TTestR<int> >::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<const TTestS<int> >::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<const TTestT<int> >::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<const TTestU<int> >::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<const TTestV<int> >::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<const TTestW<int> >::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<const TTestX<int> >::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<const TTestY<int> >::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<const TTestZ<int> >::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<const TTestAA<int> >::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<const TTestAB<int> >::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<const TTestAC<int> >::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<const TTestAD<int> >::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<const TTestAE<int> >::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<const TTestAF<int> >::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<const TTestAG<int> >::value), false); + +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile TTestA<int> >::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile TTestB<int> >::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile TTestC<int> >::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile TTestD<int> >::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile TTestE<int> >::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile TTestF<int> >::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile TTestG<int> >::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile TTestH<int> >::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile TTestI<int> >::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile TTestJ<int> >::value), false); // only one method implemented! +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile TTestK<int> >::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile TTestL<int> >::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile TTestM<int> >::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile TTestN<int> >::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile TTestO<int> >::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile TTestP<int> >::value), false); // ??? +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile TTestQ<int> >::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile TTestR<int> >::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile TTestS<int> >::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile TTestT<int> >::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile TTestU<int> >::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile TTestV<int> >::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile TTestW<int> >::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile TTestX<int> >::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile TTestY<int> >::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile TTestZ<int> >::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile TTestAA<int> >::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile TTestAB<int> >::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile TTestAC<int> >::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile TTestAD<int> >::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile TTestAE<int> >::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile TTestAF<int> >::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile TTestAG<int> >::value), false); + +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile const TTestA<int> >::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile const TTestB<int> >::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile const TTestC<int> >::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile const TTestD<int> >::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile const TTestE<int> >::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile const TTestF<int> >::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile const TTestG<int> >::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile const TTestH<int> >::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile const TTestI<int> >::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile const TTestJ<int> >::value), false); // only one method implemented! +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile const TTestK<int> >::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile const TTestL<int> >::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile const TTestM<int> >::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile const TTestN<int> >::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile const TTestO<int> >::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile const TTestP<int> >::value), false); // ??? +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile const TTestQ<int> >::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile const TTestR<int> >::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile const TTestS<int> >::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile const TTestT<int> >::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile const TTestU<int> >::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile const TTestV<int> >::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile const TTestW<int> >::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile const TTestX<int> >::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile const TTestY<int> >::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile const TTestZ<int> >::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile const TTestAA<int> >::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile const TTestAB<int> >::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile const TTestAC<int> >::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile const TTestAD<int> >::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile const TTestAE<int> >::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile const TTestAF<int> >::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<volatile const TTestAG<int> >::value), false); + +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TTestA<int>& >::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TTestB<int>& >::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TTestC<int>& >::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TTestD<int>& >::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TTestE<int>& >::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TTestF<int>& >::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TTestG<int>& >::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TTestH<int>& >::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TTestI<int>& >::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TTestJ<int>& >::value), false); // only one method implemented! +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TTestK<int>& >::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TTestL<int>& >::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TTestM<int>& >::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TTestN<int>& >::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TTestO<int>& >::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TTestP<int>& >::value), false); // ??? +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TTestQ<int>& >::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TTestR<int>& >::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TTestS<int>& >::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TTestT<int>& >::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TTestU<int>& >::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TTestV<int>& >::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TTestW<int>& >::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TTestX<int>& >::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TTestY<int>& >::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TTestZ<int>& >::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TTestAA<int>& >::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TTestAB<int>& >::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TTestAC<int>& >::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TTestAD<int>& >::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TTestAE<int>& >::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TTestAF<int>& >::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_abstract<TTestAG<int>& >::value), false); +#endif +TT_TEST_END + + + + + + + diff --git a/libs/type_traits/test/is_arithmetic_test.cpp b/libs/type_traits/test/is_arithmetic_test.cpp new file mode 100644 index 0000000000..77fdc8b393 --- /dev/null +++ b/libs/type_traits/test/is_arithmetic_test.cpp @@ -0,0 +1,155 @@ + +// (C) Copyright John Maddock 2000. +// 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_arithmetic.hpp> +#endif + +TT_TEST_BEGIN(is_arithmetic) + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_arithmetic<bool>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_arithmetic<bool const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_arithmetic<bool volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_arithmetic<bool const volatile>::value, true); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_arithmetic<signed char>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_arithmetic<signed char const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_arithmetic<signed char volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_arithmetic<signed char const volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_arithmetic<unsigned char>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_arithmetic<char>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_arithmetic<unsigned char const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_arithmetic<char const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_arithmetic<unsigned char volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_arithmetic<char volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_arithmetic<unsigned char const volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_arithmetic<char const volatile>::value, true); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_arithmetic<unsigned short>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_arithmetic<short>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_arithmetic<unsigned short const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_arithmetic<short const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_arithmetic<unsigned short volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_arithmetic<short volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_arithmetic<unsigned short const volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_arithmetic<short const volatile>::value, true); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_arithmetic<unsigned int>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_arithmetic<int>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_arithmetic<unsigned int const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_arithmetic<int const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_arithmetic<unsigned int volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_arithmetic<int volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_arithmetic<unsigned int const volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_arithmetic<int const volatile>::value, true); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_arithmetic<unsigned long>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_arithmetic<long>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_arithmetic<unsigned long const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_arithmetic<long const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_arithmetic<unsigned long volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_arithmetic<long volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_arithmetic<unsigned long const volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_arithmetic<long const volatile>::value, true); + +#ifdef BOOST_HAS_LONG_LONG + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_arithmetic< ::boost::ulong_long_type>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_arithmetic< ::boost::long_long_type>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_arithmetic< ::boost::ulong_long_type const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_arithmetic< ::boost::long_long_type const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_arithmetic< ::boost::ulong_long_type volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_arithmetic< ::boost::long_long_type volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_arithmetic< ::boost::ulong_long_type const volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_arithmetic< ::boost::long_long_type const volatile>::value, true); + +#endif + +#ifdef BOOST_HAS_MS_INT64 + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_arithmetic<unsigned __int8>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_arithmetic<__int8>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_arithmetic<unsigned __int8 const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_arithmetic<__int8 const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_arithmetic<unsigned __int8 volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_arithmetic<__int8 volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_arithmetic<unsigned __int8 const volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_arithmetic<__int8 const volatile>::value, true); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_arithmetic<unsigned __int16>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_arithmetic<__int16>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_arithmetic<unsigned __int16 const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_arithmetic<__int16 const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_arithmetic<unsigned __int16 volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_arithmetic<__int16 volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_arithmetic<unsigned __int16 const volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_arithmetic<__int16 const volatile>::value, true); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_arithmetic<unsigned __int32>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_arithmetic<__int32>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_arithmetic<unsigned __int32 const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_arithmetic<__int32 const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_arithmetic<unsigned __int32 volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_arithmetic<__int32 volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_arithmetic<unsigned __int32 const volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_arithmetic<__int32 const volatile>::value, true); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_arithmetic<unsigned __int64>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_arithmetic<__int64>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_arithmetic<unsigned __int64 const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_arithmetic<__int64 const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_arithmetic<unsigned __int64 volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_arithmetic<__int64 volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_arithmetic<unsigned __int64 const volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_arithmetic<__int64 const volatile>::value, true); + +#endif + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_arithmetic<float>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_arithmetic<float const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_arithmetic<float volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_arithmetic<float const volatile>::value, true); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_arithmetic<double>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_arithmetic<double const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_arithmetic<double volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_arithmetic<double const volatile>::value, true); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_arithmetic<long double>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_arithmetic<long double const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_arithmetic<long double volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_arithmetic<long double const volatile>::value, true); + +// +// cases that should not be true: +// +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_arithmetic<void>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_arithmetic<UDT>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_arithmetic<test_abc1>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_arithmetic<empty_UDT>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_arithmetic<float*>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_arithmetic<float&>::value, false); +#ifndef BOOST_NO_RVALUE_REFERENCES +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_arithmetic<float&&>::value, false); +#endif +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_arithmetic<const float&>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_arithmetic<float[2]>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_arithmetic<foo0_t>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_arithmetic<incomplete_type>::value, false); + +TT_TEST_END + + + + + + + + diff --git a/libs/type_traits/test/is_array_test.cpp b/libs/type_traits/test/is_array_test.cpp new file mode 100644 index 0000000000..3161906c4c --- /dev/null +++ b/libs/type_traits/test/is_array_test.cpp @@ -0,0 +1,55 @@ + +// (C) Copyright John Maddock 2000. +// 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_array.hpp> +#endif + +struct convertible_to_pointer +{ + operator char*() const; +}; + +TT_TEST_BEGIN(is_array) + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_array<int>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_array<int*>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_array<const int*>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_array<const volatile int*>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_array<int*const>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_array<const int*volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_array<const volatile int*const>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_array<int[2]>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_array<const int[2]>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_array<const volatile int[2]>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_array<int[2][3]>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_array<UDT[2]>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_array<int(&)[2]>::value, false); +#ifndef BOOST_NO_RVALUE_REFERENCES +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_array<int(&&)[2]>::value, false); +#endif +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_array<f1>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_array<void>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_array<test_abc1>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_array<convertible_to_pointer>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_array<test_abc1>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_array<foo0_t>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_array<incomplete_type>::value, false); + + +TT_TEST_END + + + + + + + + diff --git a/libs/type_traits/test/is_base_and_derived_test.cpp b/libs/type_traits/test/is_base_and_derived_test.cpp new file mode 100644 index 0000000000..38e8fa3bef --- /dev/null +++ b/libs/type_traits/test/is_base_and_derived_test.cpp @@ -0,0 +1,70 @@ + +// (C) Copyright John Maddock 2000. +// 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_base_and_derived.hpp> +#endif + +// +// Additional tests added for VC7.1 bug, 2005/04/21 +// +struct marker{}; +struct foo{ int x; }; + +template<class Class,typename Type,Type Class::*PtrToMember> +struct class_member{}; +template<class Class,typename Type,Type Class::*PtrToMember> +struct class_member2 : public marker{}; + + +TT_TEST_BEGIN(is_base_and_derived) + +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_base_and_derived<Derived,Base>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_base_and_derived<Derived,Derived>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_base_and_derived<Base,Base>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_base_and_derived<const Base,Base>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_base_and_derived<Base,Derived>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_base_and_derived<Base,MultiBase>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_base_and_derived<Derived,MultiBase>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_base_and_derived<Derived2,MultiBase>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_base_and_derived<Base,PrivateBase>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_base_and_derived<NonDerived,Base>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_base_and_derived<Base,void>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_base_and_derived<Base,const void>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_base_and_derived<void,Derived>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_base_and_derived<const void,Derived>::value), false); +#if defined(TEST_STD) && (TEST_STD < 2006) +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_base_and_derived<int, int>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_base_and_derived<const int, int>::value), true); +#else +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_base_and_derived<int, int>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_base_and_derived<const int, int>::value), false); +#endif +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_base_and_derived<VB,VD>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_base_and_derived<VD,VB>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_base_and_derived<test_abc1,test_abc3>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_base_and_derived<test_abc3,test_abc1>::value), false); + +typedef class_member<foo,int,&foo::x> mem_type; +typedef class_member2<foo,int,&foo::x> mem2_type; +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_base_and_derived<marker, mem_type>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_base_and_derived<marker, mem2_type>::value), true); + +TT_TEST_END + + + + + + + + + diff --git a/libs/type_traits/test/is_base_of_test.cpp b/libs/type_traits/test/is_base_of_test.cpp new file mode 100644 index 0000000000..86c575456d --- /dev/null +++ b/libs/type_traits/test/is_base_of_test.cpp @@ -0,0 +1,59 @@ + +// (C) Copyright John Maddock 2005. +// 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_base_of.hpp> +#endif + + + +TT_TEST_BEGIN(is_base_of) + +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_base_of<Derived,Base>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_base_of<Derived,Derived>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_base_of<Derived,const Derived>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_base_of<Base,Base>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_base_of<Base,Derived>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_base_of<const Base,Derived>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_base_of<Base,const Derived>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_base_of<Base,MultiBase>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_base_of<Derived,MultiBase>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_base_of<Derived2,MultiBase>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_base_of<Base,PrivateBase>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_base_of<NonDerived,Base>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_base_of<Base,void>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_base_of<Base,const void>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_base_of<void,Derived>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_base_of<const void,Derived>::value), false); +#if defined(TEST_STD) && (TEST_STD < 2006) +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_base_of<int, int>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_base_of<const int, int>::value), true); +#else +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_base_of<int, int>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_base_of<const int, int>::value), false); +#endif +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_base_of<VB,VD>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_base_of<VD,VB>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_base_of<test_abc1,test_abc3>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_base_of<test_abc3,test_abc1>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_base_of<Base,virtual_inherit1>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_base_of<virtual_inherit1,Base>::value), false); + +TT_TEST_END + + + + + + + + + diff --git a/libs/type_traits/test/is_class_test.cpp b/libs/type_traits/test/is_class_test.cpp new file mode 100644 index 0000000000..6dd33d79cd --- /dev/null +++ b/libs/type_traits/test/is_class_test.cpp @@ -0,0 +1,69 @@ + +// (C) Copyright John Maddock 2000. +// 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_class.hpp> +#endif +#include <iostream> + +TT_TEST_BEGIN(is_class) + + BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_class<int>::value, false); + BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_class<const int>::value, false); + BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_class<volatile int>::value, false); + BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_class<int*>::value, false); + BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_class<int* const>::value, false); + BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_class<int[2]>::value, false); + BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_class<int const[2]>::value, false); + BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_class<int&>::value, false); +#ifndef BOOST_NO_RVALUE_REFERENCES + BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_class<int&&>::value, false); +#endif + BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_class<mf4>::value, false); + BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_class<f1>::value, false); + BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_class<enum_UDT>::value, false); + +#if defined(BOOST_HAS_TYPE_TRAITS_INTRINSICS) && !defined(__sgi) + BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_class<union_UDT>::value, false); + BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_class<POD_union_UDT>::value, false); + BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_class<empty_union_UDT>::value, false); + BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_class<empty_POD_union_UDT>::value, false); +#else + std::cout << + "\n<note>\n" + "This compiler version does not provide support for is_class on\n" + "union types. Such support is not currently required by the\n" + "C++ Standard. It will be required to support the upcoming\n" + "Standard Library Technical Report.\n" + "</note>\n"; +#endif + + BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_class<UDT>::value, true); + BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_class<UDT const>::value, true); + BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_class<UDT volatile>::value, true); + BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_class<empty_UDT>::value, true); + BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_class<std::iostream>::value, true); + BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_class<test_abc1>::value, true); + BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_class<test_abc1 const>::value, true); + + BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_class<UDT*>::value, false); + BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_class<UDT[2]>::value, false); + BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_class<UDT&>::value, false); + BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_class<void>::value, false); + +TT_TEST_END + + + + + + + + diff --git a/libs/type_traits/test/is_complex_test.cpp b/libs/type_traits/test/is_complex_test.cpp new file mode 100644 index 0000000000..f47c6414ea --- /dev/null +++ b/libs/type_traits/test/is_complex_test.cpp @@ -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 + + + + + + + + + diff --git a/libs/type_traits/test/is_compound_test.cpp b/libs/type_traits/test/is_compound_test.cpp new file mode 100644 index 0000000000..a5b40fd3df --- /dev/null +++ b/libs/type_traits/test/is_compound_test.cpp @@ -0,0 +1,31 @@ + +// (C) Copyright John Maddock 2000. +// 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_compound.hpp> +#endif + +TT_TEST_BEGIN(is_compound) + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_compound<UDT>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_compound<void*>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_compound<void>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_compound<int>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_compound<test_abc1>::value, true); + +TT_TEST_END + + + + + + + + diff --git a/libs/type_traits/test/is_const_test.cpp b/libs/type_traits/test/is_const_test.cpp new file mode 100644 index 0000000000..856da5c118 --- /dev/null +++ b/libs/type_traits/test/is_const_test.cpp @@ -0,0 +1,49 @@ + +// (C) Copyright John Maddock 2000. +// 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_const.hpp> +#endif + +TT_TEST_BEGIN(is_const) + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_const<void>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_const<const void>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_const<test_abc1>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_const<const test_abc1>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_const<int>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_const<const int>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_const<const UDT>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_const<const volatile UDT>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_const<const int&>::value, false); +#ifndef BOOST_NO_RVALUE_REFERENCES +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_const<const int&&>::value, false); +#endif +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_const<cr_type>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_const<incomplete_type>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_const<foo0_t>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_const<const int[2]>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_const<int[2]>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_const<volatile int[2]>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_const<const volatile int[2]>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_const<const volatile int[]>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_const<volatile int[]>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_const<const int[]>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_const<int[]>::value, false); + +TT_TEST_END + + + + + + + + diff --git a/libs/type_traits/test/is_convertible_test.cpp b/libs/type_traits/test/is_convertible_test.cpp new file mode 100644 index 0000000000..7c04e91fd9 --- /dev/null +++ b/libs/type_traits/test/is_convertible_test.cpp @@ -0,0 +1,191 @@ + +// (C) Copyright John Maddock 2000. +// 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_convertible.hpp> +#endif +#include <boost/utility/enable_if.hpp> + + +template <class T> +struct convertible_from +{ + convertible_from(T); +}; + +struct base2 { }; +struct middle2 : public virtual base2 { }; +struct derived2 : public middle2 { }; + +#if !defined(BOOST_NO_RVALUE_REFERENCES) + +template<typename T> +struct test_bug_4530 +{ + template<typename A> + test_bug_4530(A&&, typename boost::enable_if<boost::is_convertible<A&&, T> >::type* =0); +}; + +struct A4530 +{ + template <class T> + A4530(T); +}; + +#endif + +#ifdef BOOST_MSVC + +struct bug_5271a +{ + __declspec(align(16)) int value; +}; + +struct bug_5271b +{ + __declspec(align(16)) int value; + bug_5271b(int v) : value(v) {} +}; + +#endif + +TT_TEST_BEGIN(is_convertible) + +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_convertible<Derived,Base>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_convertible<Derived,Derived>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_convertible<Base,Base>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_convertible<Base,Derived>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_convertible<Derived,Derived>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_convertible<NonDerived,Base>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_convertible<float,int>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_convertible<virtual_inherit2,virtual_inherit1>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_convertible<VD,VB>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_convertible<polymorphic_derived1,polymorphic_base>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_convertible<polymorphic_derived2,polymorphic_base>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_convertible<polymorphic_base,polymorphic_derived1>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_convertible<polymorphic_base,polymorphic_derived2>::value), false); +#ifndef TEST_STD +// Ill-formed behaviour, supported by Boost as an extension: +#ifndef BOOST_NO_IS_ABSTRACT +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_convertible<test_abc1,test_abc1>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_convertible<Base,test_abc1>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_convertible<polymorphic_derived2,test_abc1>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_convertible<int,test_abc1>::value), false); +#endif +#endif + +// The following four do not compile without member template support: +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_convertible<float,void>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_convertible<void,void>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_convertible<void,float>::value), false); + +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_convertible<enum1, int>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_convertible<Derived*, Base*>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_convertible<Base*, Derived*>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_convertible<Derived&, Base&>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_convertible<Base&, Derived&>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_convertible<const Derived*, const Base*>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_convertible<const Base*, const Derived*>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_convertible<const Derived&, const Base&>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_convertible<const Base&, const Derived&>::value), false); + +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_convertible<const int *, int*>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_convertible<const int&, int&>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_convertible<const int*, int[3]>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_convertible<const int&, int>::value), true); +#ifndef BOOST_NO_RVALUE_REFERENCES +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_convertible<const int&&, int>::value), true); +#endif +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_convertible<int(&)[4], const int*>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_convertible<int(&)(int), int(*)(int)>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_convertible<int *, const int*>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_convertible<int&, const int&>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_convertible<int[2], int*>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_convertible<int[2], const int*>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_convertible<const int[2], int*>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_convertible<int*, int[3]>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_convertible<test_abc3, const test_abc1&>::value), true); + +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_convertible<non_pointer, void*>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_convertible<non_pointer, int*>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_convertible<non_int_pointer, int*>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_convertible<non_int_pointer, void*>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_convertible<test_abc1&, test_abc2&>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_convertible<test_abc1&, int_constructible>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_convertible<int_constructible, test_abc1&>::value), false); +#if !defined(BOOST_NO_IS_ABSTRACT) && !(defined(__hppa) && defined(__HP_aCC)) +// +// This doesn't work with aCC on PA RISC even though the is_abstract tests do +// all pass, this may indicate a deeper problem... +// +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_convertible<test_abc1&, test_abc2>::value), false); +#endif + +// +// the following tests all involve user defined conversions which do +// not compile with Borland C++ Builder 5: +// +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_convertible<int, int_constructible>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_convertible<float,convertible_from<float> >::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_convertible<float,convertible_from<float const&> >::value), true); +// +// These two tests give different results with different compilers, we used to require *true* results +// from these, but C++0x behaviour requires *false*: +// +//BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_convertible<float,convertible_from<float&> >::value), false); +//BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_convertible<char,convertible_from<char&> >::value), false); + +#if !(defined(__GNUC__) && (__GNUC__ < 4)) +// GCC 3.x emits warnings here, which causes the tests to fail when we compile with warnings-as-errors: +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_convertible<float,convertible_from<char> >::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_convertible<float,convertible_from<char const&> >::value), true); +#endif +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_convertible<float,convertible_from<char&> >::value), false); + +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_convertible<char,convertible_from<char> >::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_convertible<char,convertible_from<char const&> >::value), true); + +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_convertible<float&,convertible_from<float> >::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_convertible<float const&,convertible_from<float> >::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_convertible<float&,convertible_from<float&> >::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_convertible<float const&,convertible_from<float const&> >::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_convertible<float&,convertible_from<float const&> >::value), true); + +// +// the following all generate warnings unless we can find a way to +// suppress them: +// +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_convertible<float,int>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_convertible<double,int>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_convertible<double,float>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_convertible<long,int>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_convertible<int,char>::value), true); +#ifdef BOOST_HAS_LONG_LONG +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_convertible<boost::long_long_type,int>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_convertible<boost::long_long_type,char>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_convertible<boost::long_long_type,float>::value), true); +#elif defined(BOOST_HAS_MS_INT64) +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_convertible<__int64,int>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_convertible<__int64,char>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_convertible<__int64,float>::value), true); +#endif + +#ifndef BOOST_NO_RVALUE_REFERENCES +// Test bug case 4530: +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_convertible<test_bug_4530<A4530>,A4530>::value), true); +#endif + +#if defined(BOOST_MSVC) && (BOOST_MSVC > 1310) +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_convertible<int, bug_5271a>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_convertible<int, bug_5271b>::value), true); +#endif + +TT_TEST_END + diff --git a/libs/type_traits/test/is_empty_test.cpp b/libs/type_traits/test/is_empty_test.cpp new file mode 100644 index 0000000000..83da3276bf --- /dev/null +++ b/libs/type_traits/test/is_empty_test.cpp @@ -0,0 +1,54 @@ + +// (C) Copyright John Maddock 2000. +// 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_empty.hpp> +#endif + +struct non_default_constructable_UDT +{ + non_default_constructable_UDT(const non_default_constructable_UDT&){} +private: + non_default_constructable_UDT(){} +}; + +TT_TEST_BEGIN(is_empty) + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_empty<int>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_empty<int*>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_empty<int&>::value, false); +#ifndef BOOST_NO_RVALUE_REFERENCES +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_empty<int&&>::value, false); +#endif +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_empty<void>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_empty<int[2]>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_empty<f1>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_empty<mf1>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_empty<UDT>::value, false); + +BOOST_CHECK_SOFT_INTEGRAL_CONSTANT(::tt::is_empty<empty_UDT>::value, true, false); +BOOST_CHECK_SOFT_INTEGRAL_CONSTANT(::tt::is_empty<empty_POD_UDT>::value, true, false); +BOOST_CHECK_SOFT_INTEGRAL_CONSTANT(::tt::is_empty<non_default_constructable_UDT>::value, true, false); +BOOST_CHECK_SOFT_INTEGRAL_CONSTANT(::tt::is_empty<boost::noncopyable>::value, true, false); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_empty<enum_UDT>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_empty<non_empty>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_empty<const non_empty&>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_empty<foo4_t>::value, false); + +TT_TEST_END + + + + + + + + diff --git a/libs/type_traits/test/is_enum_test.cpp b/libs/type_traits/test/is_enum_test.cpp new file mode 100644 index 0000000000..386b644a88 --- /dev/null +++ b/libs/type_traits/test/is_enum_test.cpp @@ -0,0 +1,36 @@ + +// (C) Copyright John Maddock 2000. +// 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_enum.hpp> +#endif + +TT_TEST_BEGIN(is_enum) + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_enum<int>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_enum<enum_UDT>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_enum<int_convertible>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_enum<int&>::value, false); +#ifndef BOOST_NO_RVALUE_REFERENCES +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_enum<int&&>::value, false); +#endif +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_enum<boost::noncopyable>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_enum<void>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_enum<test_abc1>::value, false); + +TT_TEST_END + + + + + + + + diff --git a/libs/type_traits/test/is_float_test.cpp b/libs/type_traits/test/is_float_test.cpp new file mode 100644 index 0000000000..4deaa2ce39 --- /dev/null +++ b/libs/type_traits/test/is_float_test.cpp @@ -0,0 +1,67 @@ + +// (C) Copyright John Maddock 2000. +// 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_float.hpp> +#endif + +TT_TEST_BEGIN(is_float) + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_float<float>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_float<float const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_float<float volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_float<float const volatile>::value, true); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_float<double>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_float<double const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_float<double volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_float<double const volatile>::value, true); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_float<long double>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_float<long double const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_float<long double volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_float<long double const volatile>::value, true); + +// +// cases that should not be true: +// +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_float<void>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_float<int>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_float<UDT>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_float<test_abc1>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_float<empty_UDT>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_float<float*>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_float<float&>::value, false); +#ifndef BOOST_NO_RVALUE_REFERENCES +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_float<float&&>::value, false); +#endif +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_float<const float&>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_float<float[2]>::value, false); + +// +// tricky cases: +// +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_float<test_abc1>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_float<foo0_t>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_float<foo1_t>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_float<foo2_t>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_float<foo3_t>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_float<foo4_t>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_float<incomplete_type>::value, false); + +TT_TEST_END + + + + + + + + diff --git a/libs/type_traits/test/is_floating_point_test.cpp b/libs/type_traits/test/is_floating_point_test.cpp new file mode 100644 index 0000000000..8b7bb635c1 --- /dev/null +++ b/libs/type_traits/test/is_floating_point_test.cpp @@ -0,0 +1,67 @@ + +// (C) Copyright John Maddock 2005. +// 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_floating_point.hpp> +#endif + +TT_TEST_BEGIN(is_floating_point) + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_floating_point<float>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_floating_point<float const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_floating_point<float volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_floating_point<float const volatile>::value, true); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_floating_point<double>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_floating_point<double const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_floating_point<double volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_floating_point<double const volatile>::value, true); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_floating_point<long double>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_floating_point<long double const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_floating_point<long double volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_floating_point<long double const volatile>::value, true); + +// +// cases that should not be true: +// +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_floating_point<void>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_floating_point<int>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_floating_point<UDT>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_floating_point<test_abc1>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_floating_point<empty_UDT>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_floating_point<float*>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_floating_point<float&>::value, false); +#ifndef BOOST_NO_RVALUE_REFERENCES +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_floating_point<float&&>::value, false); +#endif +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_floating_point<const float&>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_floating_point<float[2]>::value, false); + +// +// tricky cases: +// +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_floating_point<test_abc1>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_floating_point<foo0_t>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_floating_point<foo1_t>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_floating_point<foo2_t>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_floating_point<foo3_t>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_floating_point<foo4_t>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_floating_point<incomplete_type>::value, false); + +TT_TEST_END + + + + + + + + diff --git a/libs/type_traits/test/is_function_test.cpp b/libs/type_traits/test/is_function_test.cpp new file mode 100644 index 0000000000..902f94aa2a --- /dev/null +++ b/libs/type_traits/test/is_function_test.cpp @@ -0,0 +1,70 @@ + +// (C) Copyright John Maddock 2000. +// 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_function.hpp> +#endif + +TT_TEST_BEGIN(is_function) + +typedef void foo0_t(); +typedef void foo1_t(int); +typedef void foo2_t(int&, double); +typedef void foo3_t(int&, bool, int, int); +typedef void foo4_t(int, bool, int*, int[], int, int, int, int, int); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_function<foo0_t>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_function<foo1_t>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_function<foo2_t>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_function<foo3_t>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_function<foo4_t>::value, true); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_function<void>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_function<int>::value, false); +#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_function<int&>::value, false); +#ifndef BOOST_NO_RVALUE_REFERENCES +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_function<int&&>::value, false); +#endif +#else +std::cout << +"<note>is_function will fail with some types (references for example)" +"if the compiler doesn't support partial specialisation of class templates." +"These are *not* tested here</note>" << std::endl; +#endif +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_function<int*>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_function<int[]>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_function<test_abc1>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_function<int (*)(int)>::value, false); + +#ifdef BOOST_TT_TEST_MS_FUNC_SIGS +typedef void __stdcall sfoo0_t(); +typedef void __stdcall sfoo1_t(int); +typedef void __stdcall sfoo2_t(int&, double); +typedef void __stdcall sfoo3_t(int&, bool, int, int); +typedef void __stdcall sfoo4_t(int, bool, int*, int[], int, int, int, int, int); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_function<sfoo0_t>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_function<sfoo1_t>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_function<sfoo2_t>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_function<sfoo3_t>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_function<sfoo4_t>::value, true); + +#endif + +TT_TEST_END + + + + + + + + diff --git a/libs/type_traits/test/is_fundamental_test.cpp b/libs/type_traits/test/is_fundamental_test.cpp new file mode 100644 index 0000000000..6eee342f1b --- /dev/null +++ b/libs/type_traits/test/is_fundamental_test.cpp @@ -0,0 +1,159 @@ + +// (C) Copyright John Maddock 2000. +// 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_fundamental.hpp> +#endif + +TT_TEST_BEGIN(is_fundamental) + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_fundamental<void>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_fundamental<void const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_fundamental<void volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_fundamental<void const volatile>::value, true); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_fundamental<bool>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_fundamental<bool const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_fundamental<bool volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_fundamental<bool const volatile>::value, true); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_fundamental<signed char>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_fundamental<signed char const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_fundamental<signed char volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_fundamental<signed char const volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_fundamental<unsigned char>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_fundamental<char>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_fundamental<unsigned char const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_fundamental<char const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_fundamental<unsigned char volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_fundamental<char volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_fundamental<unsigned char const volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_fundamental<char const volatile>::value, true); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_fundamental<unsigned short>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_fundamental<short>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_fundamental<unsigned short const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_fundamental<short const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_fundamental<unsigned short volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_fundamental<short volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_fundamental<unsigned short const volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_fundamental<short const volatile>::value, true); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_fundamental<unsigned int>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_fundamental<int>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_fundamental<unsigned int const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_fundamental<int const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_fundamental<unsigned int volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_fundamental<int volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_fundamental<unsigned int const volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_fundamental<int const volatile>::value, true); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_fundamental<unsigned long>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_fundamental<long>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_fundamental<unsigned long const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_fundamental<long const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_fundamental<unsigned long volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_fundamental<long volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_fundamental<unsigned long const volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_fundamental<long const volatile>::value, true); + +#ifdef BOOST_HAS_LONG_LONG + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_fundamental< ::boost::ulong_long_type>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_fundamental< ::boost::long_long_type>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_fundamental< ::boost::ulong_long_type const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_fundamental< ::boost::long_long_type const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_fundamental< ::boost::ulong_long_type volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_fundamental< ::boost::long_long_type volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_fundamental< ::boost::ulong_long_type const volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_fundamental< ::boost::long_long_type const volatile>::value, true); + +#endif + +#ifdef BOOST_HAS_MS_INT64 + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_fundamental<unsigned __int8>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_fundamental<__int8>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_fundamental<unsigned __int8 const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_fundamental<__int8 const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_fundamental<unsigned __int8 volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_fundamental<__int8 volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_fundamental<unsigned __int8 const volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_fundamental<__int8 const volatile>::value, true); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_fundamental<unsigned __int16>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_fundamental<__int16>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_fundamental<unsigned __int16 const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_fundamental<__int16 const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_fundamental<unsigned __int16 volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_fundamental<__int16 volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_fundamental<unsigned __int16 const volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_fundamental<__int16 const volatile>::value, true); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_fundamental<unsigned __int32>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_fundamental<__int32>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_fundamental<unsigned __int32 const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_fundamental<__int32 const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_fundamental<unsigned __int32 volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_fundamental<__int32 volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_fundamental<unsigned __int32 const volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_fundamental<__int32 const volatile>::value, true); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_fundamental<unsigned __int64>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_fundamental<__int64>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_fundamental<unsigned __int64 const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_fundamental<__int64 const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_fundamental<unsigned __int64 volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_fundamental<__int64 volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_fundamental<unsigned __int64 const volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_fundamental<__int64 const volatile>::value, true); + +#endif + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_fundamental<float>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_fundamental<float const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_fundamental<float volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_fundamental<float const volatile>::value, true); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_fundamental<double>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_fundamental<double const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_fundamental<double volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_fundamental<double const volatile>::value, true); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_fundamental<long double>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_fundamental<long double const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_fundamental<long double volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_fundamental<long double const volatile>::value, true); + +// +// cases that should not be true: +// +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_fundamental<UDT>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_fundamental<test_abc1>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_fundamental<empty_UDT>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_fundamental<float*>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_fundamental<float&>::value, false); +#ifndef BOOST_NO_RVALUE_REFERENCES +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_fundamental<float&&>::value, false); +#endif +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_fundamental<const float&>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_fundamental<float[2]>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_fundamental<incomplete_type>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_fundamental<foo0_t>::value, false); + +TT_TEST_END + + + + + + + + diff --git a/libs/type_traits/test/is_integral_test.cpp b/libs/type_traits/test/is_integral_test.cpp new file mode 100644 index 0000000000..445e941594 --- /dev/null +++ b/libs/type_traits/test/is_integral_test.cpp @@ -0,0 +1,146 @@ + +// (C) Copyright John Maddock 2000. +// 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_integral.hpp> +#endif + +TT_TEST_BEGIN(is_integral) + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_integral<bool>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_integral<bool const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_integral<bool volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_integral<bool const volatile>::value, true); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_integral<signed char>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_integral<signed char const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_integral<signed char volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_integral<signed char const volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_integral<unsigned char>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_integral<char>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_integral<unsigned char const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_integral<char const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_integral<unsigned char volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_integral<char volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_integral<unsigned char const volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_integral<char const volatile>::value, true); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_integral<unsigned short>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_integral<short>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_integral<unsigned short const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_integral<short const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_integral<unsigned short volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_integral<short volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_integral<unsigned short const volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_integral<short const volatile>::value, true); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_integral<unsigned int>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_integral<int>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_integral<unsigned int const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_integral<int const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_integral<unsigned int volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_integral<int volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_integral<unsigned int const volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_integral<int const volatile>::value, true); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_integral<unsigned long>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_integral<long>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_integral<unsigned long const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_integral<long const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_integral<unsigned long volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_integral<long volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_integral<unsigned long const volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_integral<long const volatile>::value, true); + +#ifdef BOOST_HAS_LONG_LONG + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_integral< ::boost::ulong_long_type>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_integral< ::boost::long_long_type>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_integral< ::boost::ulong_long_type const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_integral< ::boost::long_long_type const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_integral< ::boost::ulong_long_type volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_integral< ::boost::long_long_type volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_integral< ::boost::ulong_long_type const volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_integral< ::boost::long_long_type const volatile>::value, true); + +#endif + +#ifdef BOOST_HAS_MS_INT64 + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_integral<unsigned __int8>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_integral<__int8>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_integral<unsigned __int8 const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_integral<__int8 const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_integral<unsigned __int8 volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_integral<__int8 volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_integral<unsigned __int8 const volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_integral<__int8 const volatile>::value, true); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_integral<unsigned __int16>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_integral<__int16>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_integral<unsigned __int16 const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_integral<__int16 const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_integral<unsigned __int16 volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_integral<__int16 volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_integral<unsigned __int16 const volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_integral<__int16 const volatile>::value, true); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_integral<unsigned __int32>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_integral<__int32>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_integral<unsigned __int32 const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_integral<__int32 const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_integral<unsigned __int32 volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_integral<__int32 volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_integral<unsigned __int32 const volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_integral<__int32 const volatile>::value, true); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_integral<unsigned __int64>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_integral<__int64>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_integral<unsigned __int64 const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_integral<__int64 const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_integral<unsigned __int64 volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_integral<__int64 volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_integral<unsigned __int64 const volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_integral<__int64 const volatile>::value, true); + +#endif + +// +// cases that should not be true: +// +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_integral<void>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_integral<float>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_integral<UDT>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_integral<test_abc1>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_integral<empty_UDT>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_integral<int*>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_integral<int&>::value, false); +#ifndef BOOST_NO_RVALUE_REFERENCES +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_integral<int&&>::value, false); +#endif +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_integral<const int&>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_integral<int[2]>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_integral<test_abc1>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_integral<foo0_t>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_integral<foo1_t>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_integral<foo2_t>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_integral<foo3_t>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_integral<foo4_t>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_integral<incomplete_type>::value, false); + +TT_TEST_END + + + + + + + + diff --git a/libs/type_traits/test/is_lvalue_reference_test.cpp b/libs/type_traits/test/is_lvalue_reference_test.cpp new file mode 100644 index 0000000000..513df432fe --- /dev/null +++ b/libs/type_traits/test/is_lvalue_reference_test.cpp @@ -0,0 +1,56 @@ + +// (C) Copyright John Maddock 2000. +// 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_lvalue_reference.hpp> +#endif + +TT_TEST_BEGIN(is_lvalue_reference) + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_lvalue_reference<int&>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_lvalue_reference<const int&>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_lvalue_reference<volatile int &>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_lvalue_reference<const volatile int &>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_lvalue_reference<r_type>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_lvalue_reference<cr_type>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_lvalue_reference<UDT&>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_lvalue_reference<const UDT&>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_lvalue_reference<volatile UDT&>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_lvalue_reference<const volatile UDT&>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_lvalue_reference<int (&)(int)>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_lvalue_reference<int (&)[2]>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_lvalue_reference<int [2]>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_lvalue_reference<const int [2]>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_lvalue_reference<volatile int [2]>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_lvalue_reference<const volatile int [2]>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_lvalue_reference<bool>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_lvalue_reference<void>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_lvalue_reference<test_abc1>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_lvalue_reference<foo0_t>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_lvalue_reference<incomplete_type>::value, false); +#ifndef BOOST_NO_RVALUE_REFERENCES +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_lvalue_reference<int&&>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_lvalue_reference<UDT&&>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_lvalue_reference<const UDT&&>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_lvalue_reference<volatile UDT&&>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_lvalue_reference<const volatile UDT&&>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_lvalue_reference<int (&&)(int)>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_lvalue_reference<int (&&)[2]>::value, false); +#endif + +TT_TEST_END + + + + + + + + diff --git a/libs/type_traits/test/is_member_func_test.cpp b/libs/type_traits/test/is_member_func_test.cpp new file mode 100644 index 0000000000..4d39892167 --- /dev/null +++ b/libs/type_traits/test/is_member_func_test.cpp @@ -0,0 +1,56 @@ + +// (C) Copyright John Maddock 2000. +// 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_member_function_pointer.hpp> +#endif + +TT_TEST_BEGIN(is_member_function_pointer) + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_member_function_pointer<f1>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_member_function_pointer<f2>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_member_function_pointer<f3>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_member_function_pointer<void*>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_member_function_pointer<mf1>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_member_function_pointer<mf2>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_member_function_pointer<mf3>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_member_function_pointer<mf4>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_member_function_pointer<cmf>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_member_function_pointer<mp>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_member_function_pointer<void>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_member_function_pointer<test_abc1>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_member_function_pointer<foo0_t>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_member_function_pointer<int&>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_member_function_pointer<const int&>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_member_function_pointer<const int[2] >::value, false); +#ifndef __IBMCPP__ +// this test may not be strictly legal: +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_member_function_pointer<const int[] >::value, false); +#endif +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_member_function_pointer<void>::value, false); + +#ifdef BOOST_TT_TEST_MS_FUNC_SIGS +typedef void (__stdcall test_abc1::*scall_proc)(); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_member_function_pointer<scall_proc>::value, true); +typedef void (__fastcall test_abc1::*fcall_proc)(int); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_member_function_pointer<fcall_proc>::value, true); +typedef void (__cdecl test_abc1::*ccall_proc)(int, long, double); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_member_function_pointer<ccall_proc>::value, true); +#endif + +TT_TEST_END + + + + + + + + diff --git a/libs/type_traits/test/is_member_obj_test.cpp b/libs/type_traits/test/is_member_obj_test.cpp new file mode 100644 index 0000000000..3307120f16 --- /dev/null +++ b/libs/type_traits/test/is_member_obj_test.cpp @@ -0,0 +1,42 @@ + +// (C) Copyright John Maddock 2005. +// 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_member_object_pointer.hpp> +#endif + +typedef const double (UDT::*mp2) ; + +TT_TEST_BEGIN(is_member_object_pointer) + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_member_object_pointer<f1>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_member_object_pointer<f2>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_member_object_pointer<f3>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_member_object_pointer<void*>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_member_object_pointer<mf1>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_member_object_pointer<mf2>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_member_object_pointer<mf3>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_member_object_pointer<mf4>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_member_object_pointer<cmf>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_member_object_pointer<mp>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_member_object_pointer<mp2>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_member_object_pointer<void>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_member_object_pointer<test_abc1>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_member_object_pointer<foo0_t>::value, false); + +TT_TEST_END + + + + + + + + diff --git a/libs/type_traits/test/is_member_pointer_test.cpp b/libs/type_traits/test/is_member_pointer_test.cpp new file mode 100644 index 0000000000..02438d08be --- /dev/null +++ b/libs/type_traits/test/is_member_pointer_test.cpp @@ -0,0 +1,48 @@ + +// (C) Copyright John Maddock 2000. +// 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_member_pointer.hpp> +#endif + +TT_TEST_BEGIN(is_member_pointer) + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_member_pointer<f1>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_member_pointer<f2>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_member_pointer<f3>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_member_pointer<void*>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_member_pointer<mf1>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_member_pointer<mf2>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_member_pointer<mf3>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_member_pointer<mf4>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_member_pointer<cmf>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_member_pointer<mp>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_member_pointer<void>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_member_pointer<test_abc1>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_member_pointer<foo0_t>::value, false); + +#ifdef BOOST_TT_TEST_MS_FUNC_SIGS +typedef void (__stdcall test_abc1::*scall_proc)(); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_member_pointer<scall_proc>::value, true); +typedef void (__fastcall test_abc1::*fcall_proc)(int); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_member_pointer<fcall_proc>::value, true); +typedef void (__cdecl test_abc1::*ccall_proc)(int, long, double); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_member_pointer<ccall_proc>::value, true); +#endif + +TT_TEST_END + + + + + + + + diff --git a/libs/type_traits/test/is_object_test.cpp b/libs/type_traits/test/is_object_test.cpp new file mode 100644 index 0000000000..1be06d679a --- /dev/null +++ b/libs/type_traits/test/is_object_test.cpp @@ -0,0 +1,38 @@ + +// (C) Copyright John Maddock 2000. +// 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_object.hpp> +#endif + +TT_TEST_BEGIN(is_object) + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_object<int>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_object<UDT>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_object<int&>::value, false); +#ifndef BOOST_NO_RVALUE_REFERENCES +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_object<int&&>::value, false); +#endif +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_object<void>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_object<foo4_t>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_object<test_abc1>::value, true); +// this one is only partly correct: +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_object<incomplete_type>::value, true); + + +TT_TEST_END + + + + + + + + diff --git a/libs/type_traits/test/is_pod_test.cpp b/libs/type_traits/test/is_pod_test.cpp new file mode 100644 index 0000000000..c9d3135fc1 --- /dev/null +++ b/libs/type_traits/test/is_pod_test.cpp @@ -0,0 +1,181 @@ + +// (C) Copyright John Maddock 2000. +// 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_pod.hpp> +#endif + +TT_TEST_BEGIN(is_pod) + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<bool>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<bool const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<bool volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<bool const volatile>::value, true); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<signed char>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<signed char const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<signed char volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<signed char const volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<unsigned char>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<char>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<unsigned char const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<char const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<unsigned char volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<char volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<unsigned char const volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<char const volatile>::value, true); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<unsigned short>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<short>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<unsigned short const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<short const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<unsigned short volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<short volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<unsigned short const volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<short const volatile>::value, true); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<unsigned int>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<int>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<unsigned int const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<int const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<unsigned int volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<int volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<unsigned int const volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<int const volatile>::value, true); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<unsigned long>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<long>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<unsigned long const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<long const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<unsigned long volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<long volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<unsigned long const volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<long const volatile>::value, true); + +#ifdef BOOST_HAS_LONG_LONG + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod< ::boost::ulong_long_type>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod< ::boost::long_long_type>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod< ::boost::ulong_long_type const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod< ::boost::long_long_type const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod< ::boost::ulong_long_type volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod< ::boost::long_long_type volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod< ::boost::ulong_long_type const volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod< ::boost::long_long_type const volatile>::value, true); + +#endif + +#ifdef BOOST_HAS_MS_INT64 + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<unsigned __int8>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<__int8>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<unsigned __int8 const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<__int8 const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<unsigned __int8 volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<__int8 volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<unsigned __int8 const volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<__int8 const volatile>::value, true); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<unsigned __int16>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<__int16>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<unsigned __int16 const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<__int16 const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<unsigned __int16 volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<__int16 volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<unsigned __int16 const volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<__int16 const volatile>::value, true); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<unsigned __int32>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<__int32>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<unsigned __int32 const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<__int32 const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<unsigned __int32 volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<__int32 volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<unsigned __int32 const volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<__int32 const volatile>::value, true); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<unsigned __int64>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<__int64>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<unsigned __int64 const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<__int64 const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<unsigned __int64 volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<__int64 volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<unsigned __int64 const volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<__int64 const volatile>::value, true); + +#endif + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<float>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<float const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<float volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<float const volatile>::value, true); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<double>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<double const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<double volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<double const volatile>::value, true); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<long double>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<long double const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<long double volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<long double const volatile>::value, true); + + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<int>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<void*>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<int*const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<f1>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<f2>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<f3>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<mf1>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<mf2>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<mf3>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<mp>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<cmf>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<enum_UDT>::value, true); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<int&>::value, false); +#ifndef BOOST_NO_RVALUE_REFERENCES +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<int&&>::value, false); +#endif +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<const int&>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<int[2]>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<int[3][2]>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<int[2][4][5][6][3]>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<UDT>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<empty_UDT>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<void>::value, true); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<test_abc1>::value, false); + +// cases we would like to succeed but can't implement in the language: +BOOST_CHECK_SOFT_INTEGRAL_CONSTANT(::tt::is_pod<empty_POD_UDT>::value, true, false); +BOOST_CHECK_SOFT_INTEGRAL_CONSTANT(::tt::is_pod<POD_UDT>::value, true, false); +BOOST_CHECK_SOFT_INTEGRAL_CONSTANT(::tt::is_pod<POD_union_UDT>::value, true, false); +BOOST_CHECK_SOFT_INTEGRAL_CONSTANT(::tt::is_pod<empty_POD_union_UDT>::value, true, false); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<trivial_except_copy>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<trivial_except_destroy>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<trivial_except_assign>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<trivial_except_construct>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<wrap<trivial_except_copy> >::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<wrap<trivial_except_assign> >::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<wrap<trivial_except_destroy> >::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<wrap<trivial_except_construct> >::value, false); + +TT_TEST_END + + + + + + + + diff --git a/libs/type_traits/test/is_pointer_test.cpp b/libs/type_traits/test/is_pointer_test.cpp new file mode 100644 index 0000000000..6e4ea0758c --- /dev/null +++ b/libs/type_traits/test/is_pointer_test.cpp @@ -0,0 +1,64 @@ + +// (C) Copyright John Maddock 2000. +// 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_pointer.hpp> +#endif + +TT_TEST_BEGIN(is_pointer) + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pointer<int>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pointer<int&>::value, false); +#ifndef BOOST_NO_RVALUE_REFERENCES +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pointer<int&&>::value, false); +#endif +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pointer<int*>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pointer<const int*>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pointer<volatile int*>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pointer<non_pointer*>::value, true); + // these were false in previous versions (JM 20 Dec 2000): +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pointer<int*const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pointer<int*volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pointer<int*const volatile>::value, true); + // JM 02 Oct 2000: +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pointer<non_pointer>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pointer<int*&>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pointer<int(&)[2]>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pointer<int[2]>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pointer<char[sizeof(void*)]>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pointer<void>::value, false); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pointer<f1>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pointer<f2>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pointer<f3>::value, true); + // Steve: was 'true', should be 'false', via 3.9.2p3 +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pointer<mf1>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pointer<mf2>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pointer<mf3>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pointer<mf4>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pointer<test_abc1>::value, false); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pointer<foo0_t>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pointer<foo1_t>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pointer<foo2_t>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pointer<foo3_t>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pointer<foo4_t>::value, false); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pointer<test_abc1>::value, false); + +TT_TEST_END + + + + + + + + diff --git a/libs/type_traits/test/is_polymorphic_test.cpp b/libs/type_traits/test/is_polymorphic_test.cpp new file mode 100644 index 0000000000..b49c606dec --- /dev/null +++ b/libs/type_traits/test/is_polymorphic_test.cpp @@ -0,0 +1,91 @@ + +// (C) Copyright John Maddock 2000. +// 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_polymorphic.hpp> +#endif + +#include <exception> +#include <new> +#include <stdexcept> + +#if defined(BOOST_WINDOWS) && !defined(BOOST_DISABLE_WIN32) +#include <windows.h> // more things to test +#endif + +// this test was added to check for bug reported on 21 May 2003: +struct poly_bug { virtual int foo() = 0; }; + +TT_TEST_BEGIN(is_polymorphic) + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_polymorphic<int>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_polymorphic<const int>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_polymorphic<volatile int>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_polymorphic<int*>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_polymorphic<int* const>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_polymorphic<int[2]>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_polymorphic<int&>::value, false); +#ifndef BOOST_NO_RVALUE_REFERENCES +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_polymorphic<int&&>::value, false); +#endif +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_polymorphic<mf4>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_polymorphic<f1>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_polymorphic<enum_UDT>::value, false); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_polymorphic<UDT>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_polymorphic<empty_UDT>::value, false); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_polymorphic<UDT*>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_polymorphic<UDT[2]>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_polymorphic<UDT&>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_polymorphic<void>::value, false); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_polymorphic<VB>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_polymorphic<VD>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_polymorphic<test_abc1>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_polymorphic<test_abc2>::value, true); +#ifndef BOOST_NO_STD_LOCALE +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_polymorphic<std::iostream>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_polymorphic<std::basic_streambuf<char> >::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_polymorphic<std::basic_ios<char> >::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_polymorphic<std::basic_istream<char> >::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_polymorphic<std::basic_streambuf<char> >::value, true); +// some libraries don't make this one a polymorphic class, since this is a library +// rather than a type traits issue we won't test this for now... +//BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_polymorphic<std::ios_base>::value, true); +#endif +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_polymorphic<std::exception>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_polymorphic<std::bad_alloc>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_polymorphic<std::runtime_error>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_polymorphic<std::out_of_range>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_polymorphic<std::range_error>::value, true); + +#if defined(BOOST_WINDOWS) && !defined(BOOST_DISABLE_WIN32) +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_polymorphic<IUnknown>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_polymorphic<ITypeInfo>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_polymorphic<ITypeComp>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_polymorphic<IDispatch>::value, true); +#endif + +// +// this test was added to check for bug reported on 21 May 2003: +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_polymorphic<poly_bug>::value, true); + +TT_TEST_END + + + + + + + + + + diff --git a/libs/type_traits/test/is_reference_test.cpp b/libs/type_traits/test/is_reference_test.cpp new file mode 100644 index 0000000000..aa5ed7ff24 --- /dev/null +++ b/libs/type_traits/test/is_reference_test.cpp @@ -0,0 +1,55 @@ + +// (C) Copyright John Maddock 2000. +// 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_reference.hpp> +#endif + +TT_TEST_BEGIN(is_reference) + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_reference<int&>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_reference<const int&>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_reference<volatile int &>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_reference<const volatile int &>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_reference<r_type>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_reference<cr_type>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_reference<UDT&>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_reference<const UDT&>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_reference<volatile UDT&>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_reference<const volatile UDT&>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_reference<int (&)(int)>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_reference<int (&)[2]>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_reference<int [2]>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_reference<const int [2]>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_reference<volatile int [2]>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_reference<const volatile int [2]>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_reference<bool>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_reference<void>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_reference<test_abc1>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_reference<foo0_t>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_reference<incomplete_type>::value, false); +#ifndef BOOST_NO_RVALUE_REFERENCES +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_reference<int&&>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_reference<UDT&&>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_reference<const UDT&&>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_reference<volatile UDT&&>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_reference<const volatile UDT&&>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_reference<int (&&)[2]>::value, true); +#endif + +TT_TEST_END + + + + + + + + diff --git a/libs/type_traits/test/is_rvalue_reference_test.cpp b/libs/type_traits/test/is_rvalue_reference_test.cpp new file mode 100644 index 0000000000..4c4bd1032d --- /dev/null +++ b/libs/type_traits/test/is_rvalue_reference_test.cpp @@ -0,0 +1,54 @@ + +// (C) Copyright John Maddock 2000. +// 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_rvalue_reference.hpp> +#endif + +TT_TEST_BEGIN(is_rvalue_reference) + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_rvalue_reference<int&>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_rvalue_reference<const int&>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_rvalue_reference<volatile int &>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_rvalue_reference<const volatile int &>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_rvalue_reference<r_type>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_rvalue_reference<cr_type>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_rvalue_reference<UDT&>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_rvalue_reference<const UDT&>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_rvalue_reference<volatile UDT&>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_rvalue_reference<const volatile UDT&>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_rvalue_reference<int (&)[2]>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_rvalue_reference<int [2]>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_rvalue_reference<const int [2]>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_rvalue_reference<volatile int [2]>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_rvalue_reference<const volatile int [2]>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_rvalue_reference<bool>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_rvalue_reference<void>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_rvalue_reference<test_abc1>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_rvalue_reference<foo0_t>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_rvalue_reference<incomplete_type>::value, false); +#ifndef BOOST_NO_RVALUE_REFERENCES +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_rvalue_reference<int&&>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_rvalue_reference<UDT&&>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_rvalue_reference<const UDT&&>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_rvalue_reference<volatile UDT&&>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_rvalue_reference<const volatile UDT&&>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_rvalue_reference<int (&&)[2]>::value, true); +#endif + +TT_TEST_END + + + + + + + + diff --git a/libs/type_traits/test/is_same_test.cpp b/libs/type_traits/test/is_same_test.cpp new file mode 100644 index 0000000000..6f30cf734e --- /dev/null +++ b/libs/type_traits/test/is_same_test.cpp @@ -0,0 +1,43 @@ + +// (C) Copyright John Maddock 2000. +// 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_same.hpp> +#endif + +TT_TEST_BEGIN(is_same) + +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_same<int, int>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_same<int&, int&>::value), true); +#ifndef BOOST_NO_RVALUE_REFERENCES +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_same<int&&, int&&>::value), true); +#endif +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_same<int, const int>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_same<int, int&>::value), false); +#ifndef BOOST_NO_RVALUE_REFERENCES +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_same<int, int&&>::value), false); +#endif +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_same<const int, int&>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_same<int, const int&>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_same<int*, const int*>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_same<int*, int*const>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_same<int, int[2]>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_same<int*, int[2]>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_same<int[4], int[2]>::value), false); + +TT_TEST_END + + + + + + + + diff --git a/libs/type_traits/test/is_scalar_test.cpp b/libs/type_traits/test/is_scalar_test.cpp new file mode 100644 index 0000000000..06c6914eea --- /dev/null +++ b/libs/type_traits/test/is_scalar_test.cpp @@ -0,0 +1,160 @@ + +// (C) Copyright John Maddock 2000. +// 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_scalar.hpp> +#endif + +TT_TEST_BEGIN(is_scalar) + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<bool>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<bool const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<bool volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<bool const volatile>::value, true); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<signed char>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<signed char const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<signed char volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<signed char const volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<unsigned char>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<char>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<unsigned char const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<char const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<unsigned char volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<char volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<unsigned char const volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<char const volatile>::value, true); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<unsigned short>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<short>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<unsigned short const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<short const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<unsigned short volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<short volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<unsigned short const volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<short const volatile>::value, true); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<unsigned int>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<int>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<unsigned int const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<int const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<unsigned int volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<int volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<unsigned int const volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<int const volatile>::value, true); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<unsigned long>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<long>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<unsigned long const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<long const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<unsigned long volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<long volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<unsigned long const volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<long const volatile>::value, true); + +#ifdef BOOST_HAS_LONG_LONG + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar< ::boost::ulong_long_type>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar< ::boost::long_long_type>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar< ::boost::ulong_long_type const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar< ::boost::long_long_type const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar< ::boost::ulong_long_type volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar< ::boost::long_long_type volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar< ::boost::ulong_long_type const volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar< ::boost::long_long_type const volatile>::value, true); + +#endif + +#ifdef BOOST_HAS_MS_INT64 + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<unsigned __int8>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<__int8>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<unsigned __int8 const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<__int8 const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<unsigned __int8 volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<__int8 volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<unsigned __int8 const volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<__int8 const volatile>::value, true); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<unsigned __int16>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<__int16>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<unsigned __int16 const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<__int16 const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<unsigned __int16 volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<__int16 volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<unsigned __int16 const volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<__int16 const volatile>::value, true); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<unsigned __int32>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<__int32>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<unsigned __int32 const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<__int32 const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<unsigned __int32 volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<__int32 volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<unsigned __int32 const volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<__int32 const volatile>::value, true); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<unsigned __int64>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<__int64>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<unsigned __int64 const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<__int64 const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<unsigned __int64 volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<__int64 volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<unsigned __int64 const volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<__int64 const volatile>::value, true); + +#endif + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<float>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<float const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<float volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<float const volatile>::value, true); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<double>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<double const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<double volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<double const volatile>::value, true); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<long double>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<long double const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<long double volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<long double const volatile>::value, true); + + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<int>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<void*>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<int*const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<f1>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<f2>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<f3>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<mf1>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<mf2>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<mf3>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<mp>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<cmf>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<enum_UDT>::value, true); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<void>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<UDT>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<int&>::value, false); +#ifndef BOOST_NO_RVALUE_REFERENCES +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<int&&>::value, false); +#endif +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<test_abc1>::value, false); + +TT_TEST_END + + + + + + + + diff --git a/libs/type_traits/test/is_signed_test.cpp b/libs/type_traits/test/is_signed_test.cpp new file mode 100644 index 0000000000..7e1a9a1079 --- /dev/null +++ b/libs/type_traits/test/is_signed_test.cpp @@ -0,0 +1,42 @@ + +// (C) Copyright John Maddock 2005. +// 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_signed.hpp> +#endif + +TT_TEST_BEGIN(is_signed) + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_signed<int>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_signed<long>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_signed<short>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_signed<signed char>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_signed<unsigned int>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_signed<unsigned long>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_signed<unsigned short>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_signed<unsigned char>::value, false); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_signed<UDT>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_signed<int&>::value, false); +#ifndef BOOST_NO_RVALUE_REFERENCES +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_signed<int&&>::value, false); +#endif +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_signed<int*>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_signed<int[2]>::value, false); + +TT_TEST_END + + + + + + + + diff --git a/libs/type_traits/test/is_stateless_test.cpp b/libs/type_traits/test/is_stateless_test.cpp new file mode 100644 index 0000000000..ab3381cb71 --- /dev/null +++ b/libs/type_traits/test/is_stateless_test.cpp @@ -0,0 +1,168 @@ + +// (C) Copyright John Maddock 2000. +// 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_stateless.hpp> +#endif + +TT_TEST_BEGIN(is_stateless) + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_stateless<bool>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_stateless<bool const>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_stateless<bool volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_stateless<bool const volatile>::value, false); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_stateless<signed char>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_stateless<signed char const>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_stateless<signed char volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_stateless<signed char const volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_stateless<unsigned char>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_stateless<char>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_stateless<unsigned char const>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_stateless<char const>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_stateless<unsigned char volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_stateless<char volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_stateless<unsigned char const volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_stateless<char const volatile>::value, false); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_stateless<unsigned short>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_stateless<short>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_stateless<unsigned short const>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_stateless<short const>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_stateless<unsigned short volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_stateless<short volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_stateless<unsigned short const volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_stateless<short const volatile>::value, false); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_stateless<unsigned int>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_stateless<int>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_stateless<unsigned int const>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_stateless<int const>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_stateless<unsigned int volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_stateless<int volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_stateless<unsigned int const volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_stateless<int const volatile>::value, false); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_stateless<unsigned long>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_stateless<long>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_stateless<unsigned long const>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_stateless<long const>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_stateless<unsigned long volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_stateless<long volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_stateless<unsigned long const volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_stateless<long const volatile>::value, false); + +#ifdef BOOST_HAS_LONG_LONG + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_stateless< ::boost::ulong_long_type>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_stateless< ::boost::long_long_type>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_stateless< ::boost::ulong_long_type const>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_stateless< ::boost::long_long_type const>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_stateless< ::boost::ulong_long_type volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_stateless< ::boost::long_long_type volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_stateless< ::boost::ulong_long_type const volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_stateless< ::boost::long_long_type const volatile>::value, false); + +#endif + +#ifdef BOOST_HAS_MS_INT64 + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_stateless<unsigned __int8>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_stateless<__int8>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_stateless<unsigned __int8 const>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_stateless<__int8 const>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_stateless<unsigned __int8 volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_stateless<__int8 volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_stateless<unsigned __int8 const volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_stateless<__int8 const volatile>::value, false); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_stateless<unsigned __int16>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_stateless<__int16>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_stateless<unsigned __int16 const>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_stateless<__int16 const>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_stateless<unsigned __int16 volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_stateless<__int16 volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_stateless<unsigned __int16 const volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_stateless<__int16 const volatile>::value, false); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_stateless<unsigned __int32>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_stateless<__int32>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_stateless<unsigned __int32 const>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_stateless<__int32 const>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_stateless<unsigned __int32 volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_stateless<__int32 volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_stateless<unsigned __int32 const volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_stateless<__int32 const volatile>::value, false); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_stateless<unsigned __int64>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_stateless<__int64>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_stateless<unsigned __int64 const>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_stateless<__int64 const>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_stateless<unsigned __int64 volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_stateless<__int64 volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_stateless<unsigned __int64 const volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_stateless<__int64 const volatile>::value, false); + +#endif + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_stateless<float>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_stateless<float const>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_stateless<float volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_stateless<float const volatile>::value, false); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_stateless<double>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_stateless<double const>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_stateless<double volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_stateless<double const volatile>::value, false); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_stateless<long double>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_stateless<long double const>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_stateless<long double volatile>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_stateless<long double const volatile>::value, false); + + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_stateless<int>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_stateless<void*>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_stateless<int*const>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_stateless<f1>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_stateless<f2>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_stateless<f3>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_stateless<mf1>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_stateless<mf2>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_stateless<mf3>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_stateless<mp>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_stateless<cmf>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_stateless<enum_UDT>::value, false); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_stateless<int&>::value, false); +#ifndef BOOST_NO_RVALUE_REFERENCES +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_stateless<int&&>::value, false); +#endif +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_stateless<const int&>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_stateless<int[2]>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_stateless<int[3][2]>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_stateless<int[2][4][5][6][3]>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_stateless<UDT>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_stateless<empty_UDT>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_stateless<void>::value, false); + +// cases we would like to succeed but can't implement in the language: +BOOST_CHECK_SOFT_INTEGRAL_CONSTANT(::tt::is_stateless<empty_POD_UDT>::value, true, false); + + +TT_TEST_END + + + + + + + + diff --git a/libs/type_traits/test/is_union_test.cpp b/libs/type_traits/test/is_union_test.cpp new file mode 100644 index 0000000000..b021b299d7 --- /dev/null +++ b/libs/type_traits/test/is_union_test.cpp @@ -0,0 +1,79 @@ + +// (C) Copyright John Maddock 2000. +// 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_union.hpp> +#endif +#include <iostream> + +TT_TEST_BEGIN(is_union) + + BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_union<int>::value, false); + BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_union<const int>::value, false); + BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_union<volatile int>::value, false); + BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_union<int*>::value, false); + BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_union<int* const>::value, false); + BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_union<int[2]>::value, false); + BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_union<int&>::value, false); +#ifndef BOOST_NO_RVALUE_REFERENCES + BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_union<int&&>::value, false); +#endif + BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_union<mf4>::value, false); + BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_union<f1>::value, false); + BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_union<enum_UDT>::value, false); + +#if defined(BOOST_HAS_TYPE_TRAITS_INTRINSICS) && !defined(__sgi) + BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_union<union_UDT>::value, true); + BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_union<POD_union_UDT>::value, true); + BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_union<empty_union_UDT>::value, true); + BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_union<empty_POD_union_UDT>::value, true); + BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_union<union_UDT const>::value, true); + BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_union<POD_union_UDT volatile>::value, true); + BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_union<empty_union_UDT const volatile>::value, true); + BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_union<empty_POD_union_UDT const>::value, true); +#else + std::cout << + "\n<note>\n" + "This compiler version does not provide support for is_union on\n" + "union types. Such support is not currently required by the\n" + "C++ Standard. It will be required to support the upcoming\n" + "Standard Library Technical Report.\n" + "</note>\n"; +#endif + + BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_union<UDT>::value, false); + BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_union<UDT const>::value, false); + BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_union<UDT volatile>::value, false); + BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_union<empty_UDT>::value, false); + BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_union<std::iostream>::value, false); + + BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_union<UDT*>::value, false); + BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_union<UDT[2]>::value, false); + BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_union<UDT&>::value, false); + BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_union<void>::value, false); + + BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_union<test_abc1>::value, false); + BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_union<foo0_t>::value, false); + BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_union<foo1_t>::value, false); + BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_union<foo2_t>::value, false); + BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_union<foo3_t>::value, false); + BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_union<foo4_t>::value, false); + BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_union<incomplete_type>::value, false); + +TT_TEST_END + + + + + + + + + diff --git a/libs/type_traits/test/is_unsigned_test.cpp b/libs/type_traits/test/is_unsigned_test.cpp new file mode 100644 index 0000000000..68c2574146 --- /dev/null +++ b/libs/type_traits/test/is_unsigned_test.cpp @@ -0,0 +1,42 @@ + +// (C) Copyright John Maddock 2005. +// 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_unsigned.hpp> +#endif + +TT_TEST_BEGIN(is_signed) + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_unsigned<int>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_unsigned<long>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_unsigned<short>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_unsigned<signed char>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_unsigned<unsigned int>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_unsigned<unsigned long>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_unsigned<unsigned short>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_unsigned<unsigned char>::value, true); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_unsigned<UDT>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_unsigned<unsigned&>::value, false); +#ifndef BOOST_NO_RVALUE_REFERENCES +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_unsigned<unsigned&&>::value, false); +#endif +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_unsigned<unsigned*>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_unsigned<unsigned[2]>::value, false); + +TT_TEST_END + + + + + + + + diff --git a/libs/type_traits/test/is_virtual_base_of_test.cpp b/libs/type_traits/test/is_virtual_base_of_test.cpp new file mode 100644 index 0000000000..2877b4a176 --- /dev/null +++ b/libs/type_traits/test/is_virtual_base_of_test.cpp @@ -0,0 +1,88 @@ + +// (C) Copyright John Maddock 2009. +// 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" +#include <boost/type_traits/is_virtual_base_of.hpp> + +// for bug report 3317: https://svn.boost.org/trac/boost/ticket/3317 +class B +{ +public: + B(); + virtual ~B()throw(); +}; + +class D : public B +{ +public: + D(); + virtual ~D()throw(); +}; + +// for bug report 4453: https://svn.boost.org/trac/boost/ticket/4453 +class non_virtual_base +{ +public: + non_virtual_base(); +}; +class non_virtual_derived : public non_virtual_base +{ +public: + non_virtual_derived(); + virtual int Y(); + virtual int X(); +}; + +TT_TEST_BEGIN(is_virtual_base_of) + +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_virtual_base_of<Derived,Base>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_virtual_base_of<Derived,Derived>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_virtual_base_of<Base,Base>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_virtual_base_of<Base,Derived>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_virtual_base_of<Base,MultiBase>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_virtual_base_of<Derived,MultiBase>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_virtual_base_of<Derived2,MultiBase>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_virtual_base_of<Base,PrivateBase>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_virtual_base_of<NonDerived,Base>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_virtual_base_of<Base,void>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_virtual_base_of<Base,const void>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_virtual_base_of<void,Derived>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_virtual_base_of<const void,Derived>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_virtual_base_of<int, int>::value), false); // really it is!!!!! +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_virtual_base_of<const int, int>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_virtual_base_of<VB,VD>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_virtual_base_of<VD,VB>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_virtual_base_of<test_abc1,test_abc3>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_virtual_base_of<test_abc3,test_abc1>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_virtual_base_of<Base,virtual_inherit1>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_virtual_base_of<virtual_inherit1,Base>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_virtual_base_of<Base,virtual_inherit2>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_virtual_base_of<virtual_inherit2,Base>::value), false); +#ifndef BOOST_BROKEN_IS_BASE_AND_DERIVED +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_virtual_base_of<Base,virtual_inherit3>::value), true); +#endif +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_virtual_base_of<virtual_inherit3,Base>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_virtual_base_of<boost::noncopyable,virtual_inherit4>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_virtual_base_of<virtual_inherit4,boost::noncopyable>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_virtual_base_of<int_convertible,virtual_inherit5>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_virtual_base_of<virtual_inherit5,int_convertible>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_virtual_base_of<Base,virtual_inherit6>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_virtual_base_of<virtual_inherit6,Base>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_virtual_base_of<B,D>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_virtual_base_of<non_virtual_base,non_virtual_derived>::value), false); + +TT_TEST_END + + + + + + + + + diff --git a/libs/type_traits/test/is_void_test.cpp b/libs/type_traits/test/is_void_test.cpp new file mode 100644 index 0000000000..687fa4090d --- /dev/null +++ b/libs/type_traits/test/is_void_test.cpp @@ -0,0 +1,44 @@ + +// (C) Copyright John Maddock 2000. +// 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_void.hpp> +#endif + +TT_TEST_BEGIN(is_void) + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_void<void>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_void<void const>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_void<void volatile>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_void<void const volatile>::value, true); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_void<void*>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_void<int>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_void<test_abc1>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_void<foo0_t>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_void<foo1_t>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_void<foo2_t>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_void<foo3_t>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_void<foo4_t>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_void<incomplete_type>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_void<int&>::value, false); +#ifndef BOOST_NO_RVALUE_REFERENCES +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_void<int&&>::value, false); +#endif + +TT_TEST_END + + + + + + + + diff --git a/libs/type_traits/test/is_volatile_test.cpp b/libs/type_traits/test/is_volatile_test.cpp new file mode 100644 index 0000000000..1ce20f86fc --- /dev/null +++ b/libs/type_traits/test/is_volatile_test.cpp @@ -0,0 +1,50 @@ + +// (C) Copyright John Maddock 2000. +// 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_volatile.hpp> +#endif + +TT_TEST_BEGIN(is_volatile) + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_volatile<void>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_volatile<volatile void>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_volatile<test_abc1>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_volatile<volatile test_abc1>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_volatile<int>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_volatile<volatile int>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_volatile<volatile UDT>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_volatile<volatile const UDT>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_volatile<incomplete_type>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_volatile<foo0_t>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_volatile<volatile int[2]>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_volatile<int[2]>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_volatile<const int[2]>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_volatile<const volatile int[2]>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_volatile<const volatile int[]>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_volatile<const int[]>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_volatile<volatile int[]>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_volatile<int[]>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_volatile<int&>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_volatile<volatile int&>::value, false); +#ifndef BOOST_NO_RVALUE_REFERENCES +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_volatile<int&&>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_volatile<volatile int&&>::value, false); +#endif + +TT_TEST_END + + + + + + + + diff --git a/libs/type_traits/test/make_signed_test.cpp b/libs/type_traits/test/make_signed_test.cpp new file mode 100644 index 0000000000..af08bd5a6f --- /dev/null +++ b/libs/type_traits/test/make_signed_test.cpp @@ -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<boost::long_long_type>::type, boost::long_long_type); +#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 boost::long_long_type>::type, const boost::long_long_type); +#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 boost::long_long_type>::type, volatile boost::long_long_type); +#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 boost::long_long_type>::type, const volatile boost::long_long_type); +#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<boost::ulong_long_type>::type, boost::long_long_type); +#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 boost::ulong_long_type>::type, const boost::long_long_type); +#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 boost::ulong_long_type>::type, volatile boost::long_long_type); +#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 boost::ulong_long_type>::type, const volatile boost::long_long_type); +#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 + + diff --git a/libs/type_traits/test/make_unsigned_test.cpp b/libs/type_traits/test/make_unsigned_test.cpp new file mode 100644 index 0000000000..2ffe1b957e --- /dev/null +++ b/libs/type_traits/test/make_unsigned_test.cpp @@ -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<boost::long_long_type>::type, boost::ulong_long_type); +#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 boost::long_long_type>::type, const boost::ulong_long_type); +#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 boost::long_long_type>::type, volatile boost::ulong_long_type); +#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 boost::long_long_type>::type, const volatile boost::ulong_long_type); +#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<boost::ulong_long_type>::type, boost::ulong_long_type); +#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 boost::ulong_long_type>::type, const boost::ulong_long_type); +#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 boost::ulong_long_type>::type, volatile boost::ulong_long_type); +#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 boost::ulong_long_type>::type, const volatile boost::ulong_long_type); +#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 + + diff --git a/libs/type_traits/test/promote_basic_test.cpp b/libs/type_traits/test/promote_basic_test.cpp new file mode 100644 index 0000000000..f84a75ceb0 --- /dev/null +++ b/libs/type_traits/test/promote_basic_test.cpp @@ -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; +} + diff --git a/libs/type_traits/test/promote_enum_msvc_bug_test.cpp b/libs/type_traits/test/promote_enum_msvc_bug_test.cpp new file mode 100644 index 0000000000..3c6c9a7df2 --- /dev/null +++ b/libs/type_traits/test/promote_enum_msvc_bug_test.cpp @@ -0,0 +1,44 @@ +// Copyright 2009 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) + +// Test bug 99776 'enum UIntEnum { value = UINT_MAX } is promoted to int' +// 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 + +#include <boost/type_traits/promote.hpp> + +#include <climits> +#include <boost/static_assert.hpp> +#include <boost/type_traits/is_same.hpp> + +#include "promote_util.hpp" + +#ifdef BOOST_INTEL +// remark #1418: external function definition with no prior declaration +#pragma warning(disable:1418) +#endif + + +enum UIntEnum { UIntEnum_max = UINT_MAX }; + +template<class T> +void assert_is_uint(T) +{ + BOOST_STATIC_ASSERT((boost::is_same<T, unsigned int>::value)); +} + +void test_promote_to_uint() +{ + assert_is_uint(+UIntEnum_max); + test_cv< UIntEnum, unsigned int >(); +} + +int main() +{ + return 0; +} + diff --git a/libs/type_traits/test/promote_enum_test.cpp b/libs/type_traits/test/promote_enum_test.cpp new file mode 100644 index 0000000000..f94df5e248 --- /dev/null +++ b/libs/type_traits/test/promote_enum_test.cpp @@ -0,0 +1,157 @@ +// 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> + +#ifdef BOOST_INTEL +// remark #1418: external function definition with no prior declaration +#pragma warning(disable:1418) +#endif + +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; +} + diff --git a/libs/type_traits/test/promote_mpl_test.cpp b/libs/type_traits/test/promote_mpl_test.cpp new file mode 100644 index 0000000000..79dc1d2179 --- /dev/null +++ b/libs/type_traits/test/promote_mpl_test.cpp @@ -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; +} + diff --git a/libs/type_traits/test/promote_util.hpp b/libs/type_traits/test/promote_util.hpp new file mode 100644 index 0000000000..9d16de6f4f --- /dev/null +++ b/libs/type_traits/test/promote_util.hpp @@ -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 + diff --git a/libs/type_traits/test/rank_test.cpp b/libs/type_traits/test/rank_test.cpp new file mode 100644 index 0000000000..049c3119a8 --- /dev/null +++ b/libs/type_traits/test/rank_test.cpp @@ -0,0 +1,36 @@ + +// (C) Copyright John Maddock 2005. +// 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/rank.hpp> +#endif + +TT_TEST_BEGIN(rank) + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::rank<int>::value, 0); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::rank<int[]>::value, 1); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::rank<int[][10]>::value, 2); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::rank<int[5][10]>::value, 2); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::rank<int[5][10][40]>::value, 3); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::rank<int (&)[5][10]>::value, 0); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::rank<int (*)[5][10]>::value, 0); +#ifndef BOOST_NO_RVALUE_REFERENCES +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::rank<int (&&)[5][10]>::value, 0); +#endif + +TT_TEST_END + + + + + + + + diff --git a/libs/type_traits/test/remove_all_extents_test.cpp b/libs/type_traits/test/remove_all_extents_test.cpp new file mode 100644 index 0000000000..609d3e5425 --- /dev/null +++ b/libs/type_traits/test/remove_all_extents_test.cpp @@ -0,0 +1,67 @@ + +// (C) Copyright John Maddock 2005. +// 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" +#ifdef TEST_STD +# include <type_traits> +#else +# include <boost/type_traits/remove_all_extents.hpp> +#endif + +BOOST_DECL_TRANSFORM_TEST(remove_all_extents_test_1, ::tt::remove_all_extents, const, const) +BOOST_DECL_TRANSFORM_TEST(remove_all_extents_test_2, ::tt::remove_all_extents, volatile, volatile) +BOOST_DECL_TRANSFORM_TEST3(remove_all_extents_test_3, ::tt::remove_all_extents, [2]) +BOOST_DECL_TRANSFORM_TEST0(remove_all_extents_test_4, ::tt::remove_all_extents) +BOOST_DECL_TRANSFORM_TEST(remove_all_extents_test_5, ::tt::remove_all_extents, const &, const&) +BOOST_DECL_TRANSFORM_TEST(remove_all_extents_test_6, ::tt::remove_all_extents, *, *) +BOOST_DECL_TRANSFORM_TEST(remove_all_extents_test_7, ::tt::remove_all_extents, *volatile, *volatile) +BOOST_DECL_TRANSFORM_TEST(remove_all_extents_test_8, ::tt::remove_all_extents, const [2], const) +BOOST_DECL_TRANSFORM_TEST(remove_all_extents_test_9, ::tt::remove_all_extents, const &, const&) +BOOST_DECL_TRANSFORM_TEST(remove_all_extents_test_10, ::tt::remove_all_extents, const*, const*) +BOOST_DECL_TRANSFORM_TEST(remove_all_extents_test_11, ::tt::remove_all_extents, volatile*, volatile*) +BOOST_DECL_TRANSFORM_TEST(remove_all_extents_test_12, ::tt::remove_all_extents, const[2][3], const) +BOOST_DECL_TRANSFORM_TEST(remove_all_extents_test_13, ::tt::remove_all_extents, (&)[2], (&)[2]) +BOOST_DECL_TRANSFORM_TEST3(remove_all_extents_test_14, ::tt::remove_all_extents, []) +BOOST_DECL_TRANSFORM_TEST(remove_all_extents_test_15, ::tt::remove_all_extents, const [], const) +BOOST_DECL_TRANSFORM_TEST(remove_all_extents_test_16, ::tt::remove_all_extents, const[][3], const) +#ifndef BOOST_NO_RVALUE_REFERENCES +BOOST_DECL_TRANSFORM_TEST(remove_all_extents_test_5a, ::tt::remove_all_extents, const &&, const&&) +BOOST_DECL_TRANSFORM_TEST(remove_all_extents_test_13a, ::tt::remove_all_extents, (&&)[2], (&&)[2]) +#endif + +TT_TEST_BEGIN(remove_all_extents) + + remove_all_extents_test_1(); + remove_all_extents_test_2(); + remove_all_extents_test_3(); + remove_all_extents_test_4(); + remove_all_extents_test_5(); + remove_all_extents_test_6(); + remove_all_extents_test_7(); + remove_all_extents_test_8(); + remove_all_extents_test_9(); + remove_all_extents_test_10(); + remove_all_extents_test_11(); + remove_all_extents_test_12(); + remove_all_extents_test_13(); + remove_all_extents_test_14(); + remove_all_extents_test_15(); + remove_all_extents_test_16(); +#ifndef BOOST_NO_RVALUE_REFERENCES + remove_all_extents_test_5a(); + remove_all_extents_test_13a(); +#endif + +TT_TEST_END + + + + + + + + diff --git a/libs/type_traits/test/remove_bounds_test.cpp b/libs/type_traits/test/remove_bounds_test.cpp new file mode 100644 index 0000000000..9929f14183 --- /dev/null +++ b/libs/type_traits/test/remove_bounds_test.cpp @@ -0,0 +1,67 @@ + +// (C) Copyright John Maddock 2000. +// 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" +#ifdef TEST_STD +# include <type_traits> +#else +# include <boost/type_traits/remove_bounds.hpp> +#endif + +BOOST_DECL_TRANSFORM_TEST(remove_bounds_test_1, ::tt::remove_bounds, const, const) +BOOST_DECL_TRANSFORM_TEST(remove_bounds_test_2, ::tt::remove_bounds, volatile, volatile) +BOOST_DECL_TRANSFORM_TEST3(remove_bounds_test_3, ::tt::remove_bounds, [2]) +BOOST_DECL_TRANSFORM_TEST0(remove_bounds_test_4, ::tt::remove_bounds) +BOOST_DECL_TRANSFORM_TEST(remove_bounds_test_5, ::tt::remove_bounds, const &, const&) +BOOST_DECL_TRANSFORM_TEST(remove_bounds_test_6, ::tt::remove_bounds, *, *) +BOOST_DECL_TRANSFORM_TEST(remove_bounds_test_7, ::tt::remove_bounds, *volatile, *volatile) +BOOST_DECL_TRANSFORM_TEST(remove_bounds_test_8, ::tt::remove_bounds, const [2], const) +BOOST_DECL_TRANSFORM_TEST(remove_bounds_test_9, ::tt::remove_bounds, const &, const&) +BOOST_DECL_TRANSFORM_TEST(remove_bounds_test_10, ::tt::remove_bounds, const*, const*) +BOOST_DECL_TRANSFORM_TEST(remove_bounds_test_11, ::tt::remove_bounds, volatile*, volatile*) +BOOST_DECL_TRANSFORM_TEST(remove_bounds_test_12, ::tt::remove_bounds, const[2][3], const[3]) +BOOST_DECL_TRANSFORM_TEST(remove_bounds_test_13, ::tt::remove_bounds, (&)[2], (&)[2]) +BOOST_DECL_TRANSFORM_TEST3(remove_bounds_test_14, ::tt::remove_bounds, []) +BOOST_DECL_TRANSFORM_TEST(remove_bounds_test_15, ::tt::remove_bounds, const [], const) +BOOST_DECL_TRANSFORM_TEST(remove_bounds_test_16, ::tt::remove_bounds, const[][3], const[3]) +#ifndef BOOST_NO_RVALUE_REFERENCES +BOOST_DECL_TRANSFORM_TEST(remove_bounds_test_5a, ::tt::remove_bounds, const &&, const&&) +BOOST_DECL_TRANSFORM_TEST(remove_bounds_test_13a, ::tt::remove_bounds, (&&)[2], (&&)[2]) +#endif + +TT_TEST_BEGIN(remove_bounds) + + remove_bounds_test_1(); + remove_bounds_test_2(); + remove_bounds_test_3(); + remove_bounds_test_4(); + remove_bounds_test_5(); + remove_bounds_test_6(); + remove_bounds_test_7(); + remove_bounds_test_8(); + remove_bounds_test_9(); + remove_bounds_test_10(); + remove_bounds_test_11(); + remove_bounds_test_12(); + remove_bounds_test_13(); + remove_bounds_test_14(); + remove_bounds_test_15(); + remove_bounds_test_16(); +#ifndef BOOST_NO_RVALUE_REFERENCES + remove_bounds_test_5a(); + remove_bounds_test_13a(); +#endif + +TT_TEST_END + + + + + + + + diff --git a/libs/type_traits/test/remove_const_test.cpp b/libs/type_traits/test/remove_const_test.cpp new file mode 100644 index 0000000000..ff2987fd88 --- /dev/null +++ b/libs/type_traits/test/remove_const_test.cpp @@ -0,0 +1,59 @@ + +// (C) Copyright John Maddock 2000. +// 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" +#ifdef TEST_STD +# include <type_traits> +#else +# include <boost/type_traits/remove_const.hpp> +#endif + +BOOST_DECL_TRANSFORM_TEST3(remove_const_test_1, ::tt::remove_const, const) +BOOST_DECL_TRANSFORM_TEST(remove_const_test_2, ::tt::remove_const, volatile, volatile) +BOOST_DECL_TRANSFORM_TEST(remove_const_test_3, ::tt::remove_const, const volatile, volatile) +BOOST_DECL_TRANSFORM_TEST0(remove_const_test_4, ::tt::remove_const) +BOOST_DECL_TRANSFORM_TEST(remove_const_test_6, ::tt::remove_const, *const, *) +BOOST_DECL_TRANSFORM_TEST(remove_const_test_7, ::tt::remove_const, *volatile, *volatile) +BOOST_DECL_TRANSFORM_TEST(remove_const_test_8, ::tt::remove_const, *const volatile, *volatile) +BOOST_DECL_TRANSFORM_TEST(remove_const_test_9, ::tt::remove_const, *, *) +BOOST_DECL_TRANSFORM_TEST(remove_const_test_11, ::tt::remove_const, volatile*, volatile*) +BOOST_DECL_TRANSFORM_TEST(remove_const_test_12, ::tt::remove_const, const[2], [2]) +BOOST_DECL_TRANSFORM_TEST(remove_const_test_13, ::tt::remove_const, volatile[2], volatile[2]) +BOOST_DECL_TRANSFORM_TEST(remove_const_test_14, ::tt::remove_const, const volatile[2], volatile[2]) +BOOST_DECL_TRANSFORM_TEST(remove_const_test_15, ::tt::remove_const, [2], [2]) +BOOST_DECL_TRANSFORM_TEST(remove_const_test_16, ::tt::remove_const, const*, const*) +BOOST_DECL_TRANSFORM_TEST(remove_const_test_17, ::tt::remove_const, const*const, const*) + +TT_TEST_BEGIN(remove_const) + +BOOST_CHECK_TYPE(int, int); + + remove_const_test_1(); + remove_const_test_2(); + remove_const_test_3(); + remove_const_test_4(); + remove_const_test_6(); + remove_const_test_7(); + remove_const_test_8(); + remove_const_test_9(); + remove_const_test_11(); + remove_const_test_12(); + remove_const_test_13(); + remove_const_test_14(); + remove_const_test_15(); + remove_const_test_16(); + remove_const_test_17(); + +TT_TEST_END + + + + + + + + diff --git a/libs/type_traits/test/remove_cv_test.cpp b/libs/type_traits/test/remove_cv_test.cpp new file mode 100644 index 0000000000..869e25a599 --- /dev/null +++ b/libs/type_traits/test/remove_cv_test.cpp @@ -0,0 +1,67 @@ + +// (C) Copyright John Maddock 2000. +// 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" +#ifdef TEST_STD +# include <type_traits> +#else +# include <boost/type_traits/remove_cv.hpp> +#endif + +BOOST_DECL_TRANSFORM_TEST3(remove_cv_test_1, ::tt::remove_cv, const) +BOOST_DECL_TRANSFORM_TEST3(remove_cv_test_2, ::tt::remove_cv, volatile) +BOOST_DECL_TRANSFORM_TEST3(remove_cv_test_3, ::tt::remove_cv, const volatile) +BOOST_DECL_TRANSFORM_TEST0(remove_cv_test_4, ::tt::remove_cv) +BOOST_DECL_TRANSFORM_TEST(remove_cv_test_5, ::tt::remove_cv, const &, const&) +BOOST_DECL_TRANSFORM_TEST(remove_cv_test_6, ::tt::remove_cv, *const, *) +BOOST_DECL_TRANSFORM_TEST(remove_cv_test_7, ::tt::remove_cv, *volatile, *) +BOOST_DECL_TRANSFORM_TEST(remove_cv_test_8, ::tt::remove_cv, *const volatile, *) +BOOST_DECL_TRANSFORM_TEST(remove_cv_test_9, ::tt::remove_cv, *, *) +BOOST_DECL_TRANSFORM_TEST(remove_cv_test_10, ::tt::remove_cv, const*, const*) +BOOST_DECL_TRANSFORM_TEST(remove_cv_test_11, ::tt::remove_cv, volatile*, volatile*) +BOOST_DECL_TRANSFORM_TEST(remove_cv_test_12, ::tt::remove_cv, const[2], [2]) +BOOST_DECL_TRANSFORM_TEST(remove_cv_test_13, ::tt::remove_cv, volatile[2], [2]) +BOOST_DECL_TRANSFORM_TEST(remove_cv_test_14, ::tt::remove_cv, const volatile[2], [2]) +BOOST_DECL_TRANSFORM_TEST(remove_cv_test_15, ::tt::remove_cv, [2], [2]) +BOOST_DECL_TRANSFORM_TEST(remove_cv_test_16, ::tt::remove_cv, const*, const*) +BOOST_DECL_TRANSFORM_TEST(remove_cv_test_17, ::tt::remove_cv, const*volatile, const*) +#ifndef BOOST_NO_RVALUE_REFERENCES +BOOST_DECL_TRANSFORM_TEST(remove_cv_test_5a, ::tt::remove_cv, const &&, const&&) +#endif + +TT_TEST_BEGIN(remove_cv) + + remove_cv_test_1(); + remove_cv_test_2(); + remove_cv_test_3(); + remove_cv_test_4(); + remove_cv_test_5(); + remove_cv_test_6(); + remove_cv_test_7(); + remove_cv_test_8(); + remove_cv_test_9(); + remove_cv_test_10(); + remove_cv_test_11(); + remove_cv_test_12(); + remove_cv_test_13(); + remove_cv_test_14(); + remove_cv_test_15(); + remove_cv_test_16(); + remove_cv_test_17(); +#ifndef BOOST_NO_RVALUE_REFERENCES + remove_cv_test_5a(); +#endif + +TT_TEST_END + + + + + + + + diff --git a/libs/type_traits/test/remove_extent_test.cpp b/libs/type_traits/test/remove_extent_test.cpp new file mode 100644 index 0000000000..66407ef579 --- /dev/null +++ b/libs/type_traits/test/remove_extent_test.cpp @@ -0,0 +1,67 @@ + +// (C) Copyright John Maddock 2005. +// 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" +#ifdef TEST_STD +# include <type_traits> +#else +# include <boost/type_traits/remove_extent.hpp> +#endif + +BOOST_DECL_TRANSFORM_TEST(remove_extent_test_1, ::tt::remove_extent, const, const) +BOOST_DECL_TRANSFORM_TEST(remove_extent_test_2, ::tt::remove_extent, volatile, volatile) +BOOST_DECL_TRANSFORM_TEST3(remove_extent_test_3, ::tt::remove_extent, [2]) +BOOST_DECL_TRANSFORM_TEST0(remove_extent_test_4, ::tt::remove_extent) +BOOST_DECL_TRANSFORM_TEST(remove_extent_test_5, ::tt::remove_extent, const &, const&) +BOOST_DECL_TRANSFORM_TEST(remove_extent_test_6, ::tt::remove_extent, *, *) +BOOST_DECL_TRANSFORM_TEST(remove_extent_test_7, ::tt::remove_extent, *volatile, *volatile) +BOOST_DECL_TRANSFORM_TEST(remove_extent_test_8, ::tt::remove_extent, const [2], const) +BOOST_DECL_TRANSFORM_TEST(remove_extent_test_9, ::tt::remove_extent, const &, const&) +BOOST_DECL_TRANSFORM_TEST(remove_extent_test_10, ::tt::remove_extent, const*, const*) +BOOST_DECL_TRANSFORM_TEST(remove_extent_test_11, ::tt::remove_extent, volatile*, volatile*) +BOOST_DECL_TRANSFORM_TEST(remove_extent_test_12, ::tt::remove_extent, const[2][3], const[3]) +BOOST_DECL_TRANSFORM_TEST(remove_extent_test_13, ::tt::remove_extent, (&)[2], (&)[2]) +BOOST_DECL_TRANSFORM_TEST3(remove_extent_test_14, ::tt::remove_extent, []) +BOOST_DECL_TRANSFORM_TEST(remove_extent_test_15, ::tt::remove_extent, const [], const) +BOOST_DECL_TRANSFORM_TEST(remove_extent_test_16, ::tt::remove_extent, const[][3], const[3]) +#ifndef BOOST_NO_RVALUE_REFERENCES +BOOST_DECL_TRANSFORM_TEST(remove_extent_test_9a, ::tt::remove_extent, const &&, const&&) +BOOST_DECL_TRANSFORM_TEST(remove_extent_test_13a, ::tt::remove_extent, (&&)[2], (&&)[2]) +#endif + +TT_TEST_BEGIN(remove_extent) + + remove_extent_test_1(); + remove_extent_test_2(); + remove_extent_test_3(); + remove_extent_test_4(); + remove_extent_test_5(); + remove_extent_test_6(); + remove_extent_test_7(); + remove_extent_test_8(); + remove_extent_test_9(); + remove_extent_test_10(); + remove_extent_test_11(); + remove_extent_test_12(); + remove_extent_test_13(); + remove_extent_test_14(); + remove_extent_test_15(); + remove_extent_test_16(); +#ifndef BOOST_NO_RVALUE_REFERENCES + remove_extent_test_9a(); + remove_extent_test_13a(); +#endif + +TT_TEST_END + + + + + + + + diff --git a/libs/type_traits/test/remove_pointer_test.cpp b/libs/type_traits/test/remove_pointer_test.cpp new file mode 100644 index 0000000000..8ea738be26 --- /dev/null +++ b/libs/type_traits/test/remove_pointer_test.cpp @@ -0,0 +1,68 @@ + +// (C) Copyright John Maddock 2000. +// 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" +#ifdef TEST_STD +# include <type_traits> +#else +# include <boost/type_traits/remove_pointer.hpp> +#endif + +BOOST_DECL_TRANSFORM_TEST(remove_pointer_test_1, ::tt::remove_pointer, const, const) +BOOST_DECL_TRANSFORM_TEST(remove_pointer_test_2, ::tt::remove_pointer, volatile, volatile) +BOOST_DECL_TRANSFORM_TEST3(remove_pointer_test_3, ::tt::remove_pointer, *) +BOOST_DECL_TRANSFORM_TEST3(remove_pointer_test_3b, ::tt::remove_pointer, *const) +BOOST_DECL_TRANSFORM_TEST0(remove_pointer_test_4, ::tt::remove_pointer) +BOOST_DECL_TRANSFORM_TEST(remove_pointer_test_5, ::tt::remove_pointer, const &, const&) +BOOST_DECL_TRANSFORM_TEST(remove_pointer_test_6, ::tt::remove_pointer, &, &) +BOOST_DECL_TRANSFORM_TEST3(remove_pointer_test_7, ::tt::remove_pointer, *volatile) +BOOST_DECL_TRANSFORM_TEST(remove_pointer_test_8, ::tt::remove_pointer, const [2], const[2]) +BOOST_DECL_TRANSFORM_TEST(remove_pointer_test_9, ::tt::remove_pointer, const &, const&) +BOOST_DECL_TRANSFORM_TEST(remove_pointer_test_10, ::tt::remove_pointer, const*, const) +BOOST_DECL_TRANSFORM_TEST(remove_pointer_test_11, ::tt::remove_pointer, volatile*, volatile) +BOOST_DECL_TRANSFORM_TEST(remove_pointer_test_12, ::tt::remove_pointer, const[2][3], const[2][3]) +BOOST_DECL_TRANSFORM_TEST(remove_pointer_test_13, ::tt::remove_pointer, (&)[2], (&)[2]) +#ifndef BOOST_NO_RVALUE_REFERENCES +BOOST_DECL_TRANSFORM_TEST(remove_pointer_test_5a, ::tt::remove_pointer, const &&, const&&) +BOOST_DECL_TRANSFORM_TEST(remove_pointer_test_6a, ::tt::remove_pointer, &&, &&) +BOOST_DECL_TRANSFORM_TEST(remove_pointer_test_13a, ::tt::remove_pointer, (&&)[2], (&&)[2]) +#endif +BOOST_DECL_TRANSFORM_TEST(remove_pointer_test_14, ::tt::remove_pointer, (*)(long), (long)) +BOOST_DECL_TRANSFORM_TEST(remove_pointer_test_14b, ::tt::remove_pointer, (*const)(long), (long)) + +TT_TEST_BEGIN(remove_pointer) + + remove_pointer_test_1(); + remove_pointer_test_2(); + remove_pointer_test_3(); + remove_pointer_test_3b(); + remove_pointer_test_4(); + remove_pointer_test_5(); + remove_pointer_test_6(); + remove_pointer_test_7(); + remove_pointer_test_8(); + remove_pointer_test_9(); + remove_pointer_test_10(); + remove_pointer_test_11(); + remove_pointer_test_12(); + remove_pointer_test_13(); +#ifndef BOOST_NO_RVALUE_REFERENCES + remove_pointer_test_5a(); + remove_pointer_test_6a(); + remove_pointer_test_13a(); +#endif + remove_pointer_test_14(); + remove_pointer_test_14b(); +TT_TEST_END + + + + + + + + diff --git a/libs/type_traits/test/remove_reference_test.cpp b/libs/type_traits/test/remove_reference_test.cpp new file mode 100644 index 0000000000..d92f64c9b5 --- /dev/null +++ b/libs/type_traits/test/remove_reference_test.cpp @@ -0,0 +1,67 @@ + +// (C) Copyright John Maddock 2000. +// 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" +#ifdef TEST_STD +# include <type_traits> +#else +# include <boost/type_traits/remove_reference.hpp> +#endif + +BOOST_DECL_TRANSFORM_TEST(remove_reference_test_1, ::tt::remove_reference, const, const) +BOOST_DECL_TRANSFORM_TEST(remove_reference_test_2, ::tt::remove_reference, volatile, volatile) +BOOST_DECL_TRANSFORM_TEST3(remove_reference_test_3, ::tt::remove_reference, &) +BOOST_DECL_TRANSFORM_TEST0(remove_reference_test_4, ::tt::remove_reference) +BOOST_DECL_TRANSFORM_TEST(remove_reference_test_5, ::tt::remove_reference, const &, const) +BOOST_DECL_TRANSFORM_TEST(remove_reference_test_6, ::tt::remove_reference, *, *) +BOOST_DECL_TRANSFORM_TEST(remove_reference_test_7, ::tt::remove_reference, *volatile, *volatile) +BOOST_DECL_TRANSFORM_TEST3(remove_reference_test_8, ::tt::remove_reference, &) +BOOST_DECL_TRANSFORM_TEST(remove_reference_test_9, ::tt::remove_reference, const &, const) +BOOST_DECL_TRANSFORM_TEST(remove_reference_test_10, ::tt::remove_reference, const*, const*) +BOOST_DECL_TRANSFORM_TEST(remove_reference_test_11, ::tt::remove_reference, volatile*, volatile*) +BOOST_DECL_TRANSFORM_TEST(remove_reference_test_12, ::tt::remove_reference, const[2], const[2]) +BOOST_DECL_TRANSFORM_TEST(remove_reference_test_13, ::tt::remove_reference, (&)[2], [2]) +#ifndef BOOST_NO_RVALUE_REFERENCES +BOOST_DECL_TRANSFORM_TEST3(remove_reference_test_3a, ::tt::remove_reference, &&) +BOOST_DECL_TRANSFORM_TEST(remove_reference_test_5a, ::tt::remove_reference, const &&, const) +BOOST_DECL_TRANSFORM_TEST3(remove_reference_test_8a, ::tt::remove_reference, &&) +BOOST_DECL_TRANSFORM_TEST(remove_reference_test_9a, ::tt::remove_reference, const &&, const) +BOOST_DECL_TRANSFORM_TEST(remove_reference_test_13a, ::tt::remove_reference, (&&)[2], [2]) +#endif + +TT_TEST_BEGIN(remove_reference) + + remove_reference_test_1(); + remove_reference_test_2(); + remove_reference_test_3(); + remove_reference_test_4(); + remove_reference_test_5(); + remove_reference_test_6(); + remove_reference_test_7(); + remove_reference_test_8(); + remove_reference_test_9(); + remove_reference_test_10(); + remove_reference_test_11(); + remove_reference_test_12(); + remove_reference_test_13(); +#ifndef BOOST_NO_RVALUE_REFERENCES + remove_reference_test_3a(); + remove_reference_test_5a(); + remove_reference_test_8a(); + remove_reference_test_9a(); + remove_reference_test_13a(); +#endif + +TT_TEST_END + + + + + + + + diff --git a/libs/type_traits/test/remove_volatile_test.cpp b/libs/type_traits/test/remove_volatile_test.cpp new file mode 100644 index 0000000000..e8dcd4c8e6 --- /dev/null +++ b/libs/type_traits/test/remove_volatile_test.cpp @@ -0,0 +1,61 @@ + +// (C) Copyright John Maddock 2000. +// 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" +#ifdef TEST_STD +# include <type_traits> +#else +# include <boost/type_traits/remove_volatile.hpp> +#endif + +BOOST_DECL_TRANSFORM_TEST(remove_volatile_test_1, ::tt::remove_volatile, const, const) +BOOST_DECL_TRANSFORM_TEST3(remove_volatile_test_2, ::tt::remove_volatile, volatile) +BOOST_DECL_TRANSFORM_TEST(remove_volatile_test_3, ::tt::remove_volatile, const volatile, const) +BOOST_DECL_TRANSFORM_TEST0(remove_volatile_test_4, ::tt::remove_volatile) +BOOST_DECL_TRANSFORM_TEST0(remove_volatile_test_5, ::tt::remove_volatile) +BOOST_DECL_TRANSFORM_TEST(remove_volatile_test_6, ::tt::remove_volatile, *const, *const) +BOOST_DECL_TRANSFORM_TEST(remove_volatile_test_7, ::tt::remove_volatile, *volatile, *) +BOOST_DECL_TRANSFORM_TEST(remove_volatile_test_8, ::tt::remove_volatile, *const volatile, *const) +BOOST_DECL_TRANSFORM_TEST(remove_volatile_test_9, ::tt::remove_volatile, *, *) +BOOST_DECL_TRANSFORM_TEST(remove_volatile_test_10, ::tt::remove_volatile, *, *) +BOOST_DECL_TRANSFORM_TEST(remove_volatile_test_11, ::tt::remove_volatile, volatile*, volatile*) +BOOST_DECL_TRANSFORM_TEST(remove_volatile_test_12, ::tt::remove_volatile, const[2], const[2]) +BOOST_DECL_TRANSFORM_TEST(remove_volatile_test_13, ::tt::remove_volatile, volatile[2], [2]) +BOOST_DECL_TRANSFORM_TEST(remove_volatile_test_14, ::tt::remove_volatile, const volatile[2], const[2]) +BOOST_DECL_TRANSFORM_TEST(remove_volatile_test_15, ::tt::remove_volatile, [2], [2]) +BOOST_DECL_TRANSFORM_TEST(remove_volatile_test_16, ::tt::remove_volatile, const*, const*) +BOOST_DECL_TRANSFORM_TEST(remove_volatile_test_17, ::tt::remove_volatile, const*volatile, const*) + +TT_TEST_BEGIN(remove_volatile) + + remove_volatile_test_1(); + remove_volatile_test_2(); + remove_volatile_test_3(); + remove_volatile_test_4(); + remove_volatile_test_5(); + remove_volatile_test_6(); + remove_volatile_test_7(); + remove_volatile_test_8(); + remove_volatile_test_9(); + remove_volatile_test_10(); + remove_volatile_test_11(); + remove_volatile_test_12(); + remove_volatile_test_13(); + remove_volatile_test_14(); + remove_volatile_test_15(); + remove_volatile_test_16(); + remove_volatile_test_17(); + +TT_TEST_END + + + + + + + + diff --git a/libs/type_traits/test/test.hpp b/libs/type_traits/test/test.hpp new file mode 100644 index 0000000000..00a1e6050d --- /dev/null +++ b/libs/type_traits/test/test.hpp @@ -0,0 +1,442 @@ + +// (C) Copyright John Maddock 2000. +// 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) + +#ifndef TT_TEST_HPP +#define TT_TEST_HPP + +#include <boost/config.hpp> + +#if defined(_WIN32_WCE) && defined(BOOST_MSVC) +#pragma warning(disable:4201) +#endif + +#ifdef USE_UNIT_TEST +# include <boost/test/unit_test.hpp> +#endif +#include <boost/utility.hpp> +#include <iostream> +#include <typeinfo> + +#ifdef __BORLANDC__ +// we have to turn off these warnings overwise we get swamped by the things: +#pragma option -w-8008 -w-8066 +#endif + +#ifdef _MSC_VER +// We have to turn off warnings that occur within the test suite: +#pragma warning(disable:4127) +#endif +#ifdef BOOST_INTEL +// remark #1418: external function definition with no prior declaration +// remark #981: operands are evaluated in unspecified order +#pragma warning(disable:1418 981) +#endif + +#ifdef BOOST_INTEL +// turn off warnings from this header: +#pragma warning(push) +#pragma warning(disable:444) +#endif + +// +// basic configuration: +// +#ifdef TEST_STD + +#define tt std::tr1 + +//#define TYPE_TRAITS(x) <type_traits> +//#define TYPE_COMPARE(x) <type_compare> +//#define TYPE_TRANSFORM(x) <type_transform> + +#else + +#define tt boost + +//#define TYPE_TRAITS(x) BOOST_STRINGIZE(boost/type_traits/x.hpp) +//#define TYPE_COMPARE(x) BOOST_STRINGIZE(boost/type_traits/x.hpp) +//#define TYPE_TRANSFORM(x) BOOST_STRINGIZE(boost/type_traits/x.hpp) + +#endif + +#ifdef USE_UNIT_TEST +// +// global unit, this is not safe, but until the unit test framework uses +// shared_ptr throughout this is about as good as it gets :-( +// +boost::unit_test::test_suite* get_master_unit(const char* name = 0); + +// +// initialisation class: +// +class unit_initialiser +{ +public: + unit_initialiser(void (*f)(), const char* /*name*/) + { + get_master_unit("Type Traits")->add( BOOST_TEST_CASE(f) ); + } +}; + +#define TT_TEST_BEGIN(trait_name)\ + namespace{\ + void trait_name();\ + unit_initialiser init(trait_name, BOOST_STRINGIZE(trait_name));\ + void trait_name(){ + +#define TT_TEST_END }} + +#else + +// +// replacements for Unit test macros: +// +int error_count = 0; + +#define BOOST_CHECK_MESSAGE(pred, message)\ + do{\ + if(!(pred))\ + {\ + std::cerr << __FILE__ << ":" << __LINE__ << ": " << message << std::endl;\ + ++error_count;\ + }\ + }while(0) + +#define BOOST_WARN_MESSAGE(pred, message)\ + do{\ + if(!(pred))\ + {\ + std::cerr << __FILE__ << ":" << __LINE__ << ": " << message << std::endl;\ + }\ + }while(0) + +#define BOOST_TEST_MESSAGE(message)\ + do{ std::cout << __FILE__ << ":" << __LINE__ << ": " << message << std::endl; }while(0) + +#define BOOST_CHECK(pred)\ + do{ \ + if(!(pred)){\ + std::cout << __FILE__ << ":" << __LINE__ << ": Error in " << BOOST_STRINGIZE(pred) << std::endl;\ + ++error_count;\ + } \ + }while(0) + +#define TT_TEST_BEGIN(trait_name)\ + int main(){ +#define TT_TEST_END return error_count; } + +#endif + +#define TRANSFORM_CHECK(name, from_suffix, to_suffix)\ + BOOST_CHECK_TYPE(bool to_suffix, name<bool from_suffix>::type);\ + BOOST_CHECK_TYPE(char to_suffix, name<char from_suffix>::type);\ + BOOST_CHECK_TYPE(wchar_t to_suffix, name<wchar_t from_suffix>::type);\ + BOOST_CHECK_TYPE(signed char to_suffix, name<signed char from_suffix>::type);\ + BOOST_CHECK_TYPE(unsigned char to_suffix, name<unsigned char from_suffix>::type);\ + BOOST_CHECK_TYPE(short to_suffix, name<short from_suffix>::type);\ + BOOST_CHECK_TYPE(unsigned short to_suffix, name<unsigned short from_suffix>::type);\ + BOOST_CHECK_TYPE(int to_suffix, name<int from_suffix>::type);\ + BOOST_CHECK_TYPE(unsigned int to_suffix, name<unsigned int from_suffix>::type);\ + BOOST_CHECK_TYPE(long to_suffix, name<long from_suffix>::type);\ + BOOST_CHECK_TYPE(unsigned long to_suffix, name<unsigned long from_suffix>::type);\ + BOOST_CHECK_TYPE(float to_suffix, name<float from_suffix>::type);\ + BOOST_CHECK_TYPE(long double to_suffix, name<long double from_suffix>::type);\ + BOOST_CHECK_TYPE(double to_suffix, name<double from_suffix>::type);\ + BOOST_CHECK_TYPE(UDT to_suffix, name<UDT from_suffix>::type);\ + BOOST_CHECK_TYPE(enum1 to_suffix, name<enum1 from_suffix>::type); + +#define BOOST_DUMMY_MACRO_PARAM /**/ + +#define BOOST_DECL_TRANSFORM_TEST(name, type, from, to)\ +void name(){ TRANSFORM_CHECK(type, from, to) } +#define BOOST_DECL_TRANSFORM_TEST3(name, type, from)\ +void name(){ TRANSFORM_CHECK(type, from, BOOST_DUMMY_MACRO_PARAM) } +#define BOOST_DECL_TRANSFORM_TEST2(name, type, to)\ +void name(){ TRANSFORM_CHECK(type, BOOST_DUMMY_MACRO_PARAM, to) } +#define BOOST_DECL_TRANSFORM_TEST0(name, type)\ +void name(){ TRANSFORM_CHECK(type, BOOST_DUMMY_MACRO_PARAM, BOOST_DUMMY_MACRO_PARAM) } + + + +// +// VC++ emits an awful lot of warnings unless we define these: +#ifdef BOOST_MSVC +# pragma warning(disable:4800) +#endif + +// +// define some test types: +// +enum enum_UDT{ one, two, three }; +struct UDT +{ + UDT(); + ~UDT(); + UDT(const UDT&); + UDT& operator=(const UDT&); + int i; + + void f1(); + int f2(); + int f3(int); + int f4(int, float); +}; + +typedef void(*f1)(); +typedef int(*f2)(int); +typedef int(*f3)(int, bool); +typedef void (UDT::*mf1)(); +typedef int (UDT::*mf2)(); +typedef int (UDT::*mf3)(int); +typedef int (UDT::*mf4)(int, float); +typedef int (UDT::*mp); +typedef int (UDT::*cmf)(int) const; + +// cv-qualifiers applied to reference types should have no effect +// declare these here for later use with is_reference and remove_reference: +# ifdef BOOST_MSVC +# pragma warning(push) +# pragma warning(disable: 4181) +# elif defined(BOOST_INTEL) +# pragma warning(push) +# pragma warning(disable: 21) +# endif +// +// This is intentional: +// r_type and cr_type should be the same type +// but some compilers wrongly apply cv-qualifiers +// to reference types (this may generate a warning +// on some compilers): +// +typedef int& r_type; +#ifndef BOOST_INTEL +typedef const r_type cr_type; +#else +// recent Intel compilers generate a hard error on the above: +typedef r_type cr_type; +#endif +# ifdef BOOST_MSVC +# pragma warning(pop) +# elif defined(BOOST_INTEL) +# pragma warning(pop) +# pragma warning(disable: 985) // identifier truncated in debug information +# endif + +struct POD_UDT { int x; }; +struct empty_UDT +{ + empty_UDT(); + empty_UDT(const empty_UDT&); + ~empty_UDT(); + empty_UDT& operator=(const empty_UDT&); + bool operator==(const empty_UDT&)const; +}; +struct empty_POD_UDT +{ + bool operator==(const empty_POD_UDT&)const + { return true; } +}; +union union_UDT +{ + int x; + double y; + ~union_UDT(){} +}; +union POD_union_UDT +{ + int x; + double y; +}; +union empty_union_UDT +{ + ~empty_union_UDT(){} +}; +union empty_POD_union_UDT{}; + +struct nothrow_copy_UDT +{ + nothrow_copy_UDT(); + nothrow_copy_UDT(const nothrow_copy_UDT&)throw(); + ~nothrow_copy_UDT(){}; + nothrow_copy_UDT& operator=(const nothrow_copy_UDT&); + bool operator==(const nothrow_copy_UDT&)const + { return true; } +}; + +struct nothrow_assign_UDT +{ + nothrow_assign_UDT(); + nothrow_assign_UDT(const nothrow_assign_UDT&); + ~nothrow_assign_UDT(){}; + nothrow_assign_UDT& operator=(const nothrow_assign_UDT&)throw(){ return *this; } + bool operator==(const nothrow_assign_UDT&)const + { return true; } +}; + +struct nothrow_construct_UDT +{ + nothrow_construct_UDT()throw(); + nothrow_construct_UDT(const nothrow_construct_UDT&); + ~nothrow_construct_UDT(){}; + nothrow_construct_UDT& operator=(const nothrow_construct_UDT&){ return *this; } + bool operator==(const nothrow_construct_UDT&)const + { return true; } +}; + +class Base { }; + +class Derived : public Base { }; +class Derived2 : public Base { }; +class MultiBase : public Derived, public Derived2 {}; +class PrivateBase : private Base {}; + +class NonDerived { }; + +enum enum1 +{ + one_,two_ +}; + +enum enum2 +{ + three_,four_ +}; + +struct VB +{ + virtual ~VB(){}; +}; + +struct VD : public VB +{ + ~VD(){}; +}; +// +// struct non_pointer: +// used to verify that is_pointer does not return +// true for class types that implement operator void*() +// +struct non_pointer +{ + operator void*(){return this;} +}; +struct non_int_pointer +{ + int i; + operator int*(){return &i;} +}; +struct int_constructible +{ + int_constructible(int); +}; +struct int_convertible +{ + operator int(); +}; +// +// struct non_empty: +// used to verify that is_empty does not emit +// spurious warnings or errors. +// +struct non_empty : private boost::noncopyable +{ + int i; +}; +// +// abstract base classes: +struct test_abc1 +{ + test_abc1(); + virtual ~test_abc1(); + test_abc1(const test_abc1&); + test_abc1& operator=(const test_abc1&); + virtual void foo() = 0; + virtual void foo2() = 0; +}; + +struct test_abc2 +{ + virtual ~test_abc2(); + virtual void foo() = 0; + virtual void foo2() = 0; +}; + +struct test_abc3 : public test_abc1 +{ + virtual void foo3() = 0; +}; + +struct incomplete_type; + +struct polymorphic_base +{ + virtual ~polymorphic_base(); + virtual void method(); +}; + +struct polymorphic_derived1 : public polymorphic_base +{ +}; + +struct polymorphic_derived2 : public polymorphic_base +{ + virtual void method(); +}; + +struct virtual_inherit1 : public virtual Base { }; +struct virtual_inherit2 : public virtual_inherit1 { }; +struct virtual_inherit3 : private virtual Base {}; +struct virtual_inherit4 : public virtual boost::noncopyable {}; +struct virtual_inherit5 : public virtual int_convertible {}; +struct virtual_inherit6 : public virtual Base { virtual ~virtual_inherit6()throw(); }; + +typedef void foo0_t(); +typedef void foo1_t(int); +typedef void foo2_t(int&, double); +typedef void foo3_t(int&, bool, int, int); +typedef void foo4_t(int, bool, int*, int[], int, int, int, int, int); + +struct trivial_except_construct +{ + trivial_except_construct(); + int i; +}; + +struct trivial_except_destroy +{ + ~trivial_except_destroy(); + int i; +}; + +struct trivial_except_copy +{ + trivial_except_copy(trivial_except_copy const&); + int i; +}; + +struct trivial_except_assign +{ + trivial_except_assign& operator=(trivial_except_assign const&); + int i; +}; + +template <class T> +struct wrap +{ + T t; + int j; +protected: + wrap(); + wrap(const wrap&); + wrap& operator=(const wrap&); +}; + +#ifdef BOOST_INTEL +#pragma warning(pop) +#endif + +#endif + diff --git a/libs/type_traits/test/tricky_abstract_type_test.cpp b/libs/type_traits/test/tricky_abstract_type_test.cpp new file mode 100644 index 0000000000..4713caca97 --- /dev/null +++ b/libs/type_traits/test/tricky_abstract_type_test.cpp @@ -0,0 +1,31 @@ + +// (C) Copyright John Maddock 2000. +// 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_empty.hpp> +# include <boost/type_traits/is_stateless.hpp> +#endif + +TT_TEST_BEGIN(tricky_abstract_type_test) + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_empty<test_abc1>::value, false); +#ifndef TEST_STD +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_stateless<test_abc1>::value, false); +#endif + +TT_TEST_END + + + + + + + + diff --git a/libs/type_traits/test/tricky_add_pointer_test.cpp b/libs/type_traits/test/tricky_add_pointer_test.cpp new file mode 100644 index 0000000000..4d13497d08 --- /dev/null +++ b/libs/type_traits/test/tricky_add_pointer_test.cpp @@ -0,0 +1,51 @@ + +// (C) Copyright John Maddock 2002. +// 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" +#ifdef TEST_STD +# include <type_traits> +#else +# include <boost/type_traits/add_pointer.hpp> +#endif + +BOOST_DECL_TRANSFORM_TEST(add_pointer_test_5, ::tt::add_pointer, const &, const*) +BOOST_DECL_TRANSFORM_TEST(add_pointer_test_6, ::tt::add_pointer, &, *) +BOOST_DECL_TRANSFORM_TEST(add_pointer_test_8, ::tt::add_pointer, const [2], const (*)[2]) +BOOST_DECL_TRANSFORM_TEST(add_pointer_test_9, ::tt::add_pointer, const &, const*) +BOOST_DECL_TRANSFORM_TEST(add_pointer_test_12, ::tt::add_pointer, const[2][3], const (*)[2][3]) +BOOST_DECL_TRANSFORM_TEST(add_pointer_test_13, ::tt::add_pointer, (&)[2], (*)[2]) +#ifndef BOOST_NO_RVALUE_REFERENCES +BOOST_DECL_TRANSFORM_TEST(add_pointer_test_5a, ::tt::add_pointer, const &&, const*) +BOOST_DECL_TRANSFORM_TEST(add_pointer_test_6a, ::tt::add_pointer, &&, *) +BOOST_DECL_TRANSFORM_TEST(add_pointer_test_9a, ::tt::add_pointer, const &&, const*) +BOOST_DECL_TRANSFORM_TEST(add_pointer_test_13a, ::tt::add_pointer, (&&)[2], (*)[2]) +#endif + +TT_TEST_BEGIN(tricky_add_pointer_test) + + add_pointer_test_5(); + add_pointer_test_6(); + add_pointer_test_8(); + add_pointer_test_9(); + add_pointer_test_12(); + add_pointer_test_13(); +#ifndef BOOST_NO_RVALUE_REFERENCES + add_pointer_test_5a(); + add_pointer_test_6a(); + add_pointer_test_9a(); + add_pointer_test_13a(); +#endif + +TT_TEST_END + + + + + + + + diff --git a/libs/type_traits/test/tricky_function_type_test.cpp b/libs/type_traits/test/tricky_function_type_test.cpp new file mode 100644 index 0000000000..30ba24ca5b --- /dev/null +++ b/libs/type_traits/test/tricky_function_type_test.cpp @@ -0,0 +1,108 @@ + +// (C) Copyright John Maddock 2002. +// 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_function.hpp> +# include <boost/type_traits/is_float.hpp> +# include <boost/type_traits/is_enum.hpp> +# include <boost/type_traits/is_class.hpp> +# include <boost/type_traits/is_scalar.hpp> +# include <boost/type_traits/is_pod.hpp> +# include <boost/type_traits/has_trivial_constructor.hpp> +# include <boost/type_traits/has_trivial_copy.hpp> +# include <boost/type_traits/has_trivial_assign.hpp> +# include <boost/type_traits/has_trivial_destructor.hpp> +# include <boost/type_traits/is_compound.hpp> +# include <boost/type_traits/is_base_of.hpp> +# include <boost/type_traits/is_convertible.hpp> +#endif + +TT_TEST_BEGIN(tricky_function_type_test) + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_function<const int&>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_function<int (&)(int)>::value, false); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_class<foo0_t>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_enum<foo0_t>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<foo0_t>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_class<foo0_t>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_compound<foo0_t>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<foo0_t>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_constructor<foo0_t>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_copy<foo0_t>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_assign<foo0_t>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_destructor<foo0_t>::value, false); +#if defined(TEST_STD) && (TEST_STD < 2006) +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_base_of<foo0_t, foo0_t>::value), true); // TR1 required behaviour (new to 1.34) +#else +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_base_of<foo0_t, foo0_t>::value), false); // C++0x required behaviour (new to 1.40) +#endif +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_convertible<foo0_t, int>::value), false); + + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_class<foo1_t>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_enum<foo1_t>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<foo1_t>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_compound<foo1_t>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<foo1_t>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_constructor<foo1_t>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_copy<foo1_t>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_assign<foo1_t>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_destructor<foo1_t>::value, false); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_class<foo2_t>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_enum<foo2_t>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<foo2_t>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_compound<foo2_t>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<foo2_t>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_constructor<foo2_t>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_copy<foo2_t>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_assign<foo2_t>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_destructor<foo2_t>::value, false); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_class<foo3_t>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_enum<foo3_t>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<foo3_t>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_compound<foo3_t>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<foo3_t>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_constructor<foo3_t>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_copy<foo3_t>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_assign<foo3_t>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_destructor<foo3_t>::value, false); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_class<foo4_t>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_enum<foo4_t>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<foo4_t>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_compound<foo4_t>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<foo4_t>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_constructor<foo4_t>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_copy<foo4_t>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_assign<foo4_t>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_destructor<foo4_t>::value, false); + +typedef void foo5_t(int, bool, int*, int[], int, int, int, int, int ...); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_function<foo5_t>::value, true); + +typedef void (test_abc1::*vproc1)(...); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_member_function_pointer<vproc1>::value, true); +typedef void (test_abc1::*vproc2)(int, char, long, ...); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_member_function_pointer<vproc2>::value, true); +typedef void (test_abc1::*vproc3)(int, char, long, long, ...)const; +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_member_function_pointer<vproc3>::value, true); + +TT_TEST_END + + + + + + + + diff --git a/libs/type_traits/test/tricky_incomplete_type_test.cpp b/libs/type_traits/test/tricky_incomplete_type_test.cpp new file mode 100644 index 0000000000..573b5a6b37 --- /dev/null +++ b/libs/type_traits/test/tricky_incomplete_type_test.cpp @@ -0,0 +1,37 @@ + +// (C) Copyright John Maddock 2000. +// 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.hpp> +#endif + +TT_TEST_BEGIN(tricky_incomplete_type_test) + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_class<incomplete_type>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_compound<incomplete_type>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_enum<incomplete_type>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<incomplete_type>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_array<int[]>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_array<int[][3]>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_array<const int[]>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_array<const int[][3]>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_array<volatile int[]>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_array<volatile int[][3]>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_array<const volatile int[]>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_array<const volatile int[][3]>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_member_function_pointer<incomplete_type>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_function<incomplete_type>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pointer<incomplete_type>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_member_pointer<incomplete_type>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_member_object_pointer<incomplete_type>::value, false); + +TT_TEST_END + + diff --git a/libs/type_traits/test/tricky_is_enum_test.cpp b/libs/type_traits/test/tricky_is_enum_test.cpp new file mode 100644 index 0000000000..b7c7d382e9 --- /dev/null +++ b/libs/type_traits/test/tricky_is_enum_test.cpp @@ -0,0 +1,27 @@ + +// (C) Copyright Dave Abrahams 2003. Use, modification and distribution is +// 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_enum.hpp> +#endif + +struct convertible_to_anything +{ + template<typename T> operator T() { return 0; } +}; + + +TT_TEST_BEGIN(is_enum) + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_enum<convertible_to_anything>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_enum<int[] >::value, false); + +TT_TEST_END + + diff --git a/libs/type_traits/test/tricky_partial_spec_test.cpp b/libs/type_traits/test/tricky_partial_spec_test.cpp new file mode 100644 index 0000000000..1f7df700d6 --- /dev/null +++ b/libs/type_traits/test/tricky_partial_spec_test.cpp @@ -0,0 +1,128 @@ + +// (C) Copyright John Maddock 2000. +// 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/alignment_of.hpp> +#include <boost/type_traits/has_nothrow_assign.hpp> +#include <boost/type_traits/has_nothrow_constructor.hpp> +#include <boost/type_traits/has_nothrow_copy.hpp> +#include <boost/type_traits/is_base_and_derived.hpp> +#include <boost/type_traits/is_base_of.hpp> +#include <boost/type_traits/is_same.hpp> +#include <boost/type_traits/is_convertible.hpp> +#include <boost/type_traits/is_polymorphic.hpp> +#include <boost/type_traits/is_member_pointer.hpp> +#include <boost/type_traits/is_member_object_pointer.hpp> +#include <boost/type_traits/is_member_function_pointer.hpp> +#include <boost/type_traits/is_pointer.hpp> +#endif +#include <stdexcept> +#include <new> +#include <exception> + +// +// VC++ emits an awful lot of warnings unless we define these: +#ifdef BOOST_MSVC +# pragma warning(disable:4244) +#endif + + +template <class T> +struct align_calc +{ + char padding; + T instance; + static std::ptrdiff_t get() + { + static align_calc<T> a; + return reinterpret_cast<const char*>(&(a.instance)) - reinterpret_cast<const char*>(&(a.padding)); + } +}; + +#define ALIGNOF(x) align_calc<x>::get() + + +TT_TEST_BEGIN(tricky_partial_specialization_test) +// +// corner cases which don't compile without partial specialization +// support: +// + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::alignment_of<char&>::value, ALIGNOF(void*)); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::alignment_of<char (&)(int)>::value, ALIGNOF(void*)); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::alignment_of<char(&)[4]>::value, ALIGNOF(void*)); + +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_base_of<Base&,Derived>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_base_of<Base&,Derived&>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_base_of<Base,Derived&>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_base_of<Base,void>::value), false); +#ifndef BOOST_NO_RVALUE_REFERENCES +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_base_of<Base&&,Derived>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_base_of<Base&&,Derived&&>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_base_of<Base,Derived&&>::value), false); +#endif + +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_same<void, int>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_same<void, void>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_same<void, const void>::value), false); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_same<test_abc1, test_abc1>::value), true); +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_same<test_abc1, const test_abc1>::value), false); + +BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_convertible<void,float>::value), false); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_polymorphic<const UDT>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_polymorphic<volatile empty_UDT>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_polymorphic<const VB>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_polymorphic<const volatile VD>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_polymorphic<const test_abc1>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_polymorphic<volatile test_abc2>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_polymorphic<const std::exception>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_polymorphic<const std::bad_alloc>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_polymorphic<const std::runtime_error>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_polymorphic<const std::out_of_range>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_polymorphic<const std::range_error>::value, true); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pointer<const f1>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pointer<volatile f1>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pointer<const volatile f1>::value, true); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_member_pointer<const f1>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_member_pointer<const mp>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_member_pointer<volatile mp>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_member_pointer<const volatile mp>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_member_pointer<const mf3>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_member_pointer<volatile mf3>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_member_pointer<const volatile mf3>::value, true); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_member_object_pointer<const f1>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_member_object_pointer<const mp>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_member_object_pointer<volatile mp>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_member_object_pointer<const volatile mp>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_member_object_pointer<const mf3>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_member_object_pointer<volatile mf3>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_member_object_pointer<const volatile mf3>::value, false); + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_member_function_pointer<const f1>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_member_function_pointer<const mp>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_member_function_pointer<volatile mp>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_member_function_pointer<const volatile mp>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_member_function_pointer<const mf3>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_member_function_pointer<volatile mf3>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_member_function_pointer<const volatile mf3>::value, true); + +TT_TEST_END + + + + + + + + diff --git a/libs/type_traits/test/tricky_rvalue_test.cpp b/libs/type_traits/test/tricky_rvalue_test.cpp new file mode 100644 index 0000000000..5c01402520 --- /dev/null +++ b/libs/type_traits/test/tricky_rvalue_test.cpp @@ -0,0 +1,33 @@ + +// (C) Copyright John Maddock 2010. +// 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_lvalue_reference.hpp> +# include <boost/type_traits/is_rvalue_reference.hpp> +# include <boost/type_traits/is_reference.hpp> +#endif + +TT_TEST_BEGIN(rvalue_reference_test) + +#ifndef BOOST_NO_RVALUE_REFERENCES +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_reference<int (&&)(int)>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_rvalue_reference<int (&)(int)>::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_rvalue_reference<int (&&)(int)>::value, true); +#endif + +TT_TEST_END + + + + + + + + diff --git a/libs/type_traits/test/type_traits_test.cpp b/libs/type_traits/test/type_traits_test.cpp new file mode 100644 index 0000000000..c0fc21d49a --- /dev/null +++ b/libs/type_traits/test/type_traits_test.cpp @@ -0,0 +1,103 @@ + +// (C) Copyright John Maddock 2010. +// 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 <boost/type_traits.hpp> + +// +// Just check that each trait actually exists, not +// that it gives the correct answer, we do that elsewhere: +// + +typedef boost::add_const<int>::type t1; +typedef boost::add_cv<int>::type t2; +typedef boost::add_lvalue_reference<int>::type t3; +typedef boost::add_pointer<int>::type t4; +typedef boost::add_reference<int>::type t5; +typedef boost::add_rvalue_reference<int>::type t6; +typedef boost::add_volatile<int>::type t7; + +typedef boost::aligned_storage<2>::type t8; +typedef boost::alignment_of<int>::type t9; +typedef boost::conditional<true, int, long>::type t10; +typedef boost::common_type<int, long>::type t11; +typedef boost::decay<int[2] >::type t12; +typedef boost::extent<int[3] >::type t13; +typedef boost::floating_point_promotion<int>::type t14; +typedef boost::function_traits<int (int) > t15; + +typedef boost::has_new_operator<int> t16; +typedef boost::has_nothrow_assign<int> t17; +typedef boost::has_nothrow_constructor<int> t18; +typedef boost::has_nothrow_copy<int> t19; +typedef boost::has_nothrow_copy_constructor<int> t20; +typedef boost::has_nothrow_default_constructor<int> t21; +typedef boost::has_trivial_assign<int> t22; +typedef boost::has_trivial_constructor<int> t23; +typedef boost::has_trivial_copy<int> t24; +typedef boost::has_trivial_copy_constructor<int> t25; +typedef boost::has_trivial_default_constructor<int> t26; +typedef boost::has_trivial_destructor<int> t27; +typedef boost::has_virtual_destructor<int> t28; + +typedef boost::integral_constant<int, 2> t29; +typedef boost::integral_promotion<short>::type t30; + +typedef boost::is_abstract<int>::type t31; +typedef boost::is_arithmetic<int>::type t32; +typedef boost::is_array<int>::type t33; +typedef boost::is_base_of<int, long>::type t34; +typedef boost::is_class<int>::type t35; +typedef boost::is_complex<int>::type t36; +typedef boost::is_compound<int>::type t37; +typedef boost::is_const<int>::type t38; +typedef boost::is_convertible<int, long>::type t39; +typedef boost::is_empty<int>::type t40; +typedef boost::is_enum<int>::type t41; +typedef boost::is_floating_point<int>::type t42; +typedef boost::is_function<int>::type t43; +typedef boost::is_fundamental<int>::type t44; +typedef boost::is_integral<int>::type t45; +typedef boost::is_lvalue_reference<int>::type t46; +typedef boost::is_member_function_pointer<int>::type t47; +typedef boost::is_member_object_pointer<int>::type t48; +typedef boost::is_member_pointer<int>::type t49; +typedef boost::is_object<int>::type t50; +typedef boost::is_pod<int>::type t51; +typedef boost::is_pointer<int>::type t52; +typedef boost::is_polymorphic<int>::type t53; +typedef boost::is_reference<int>::type t54; +typedef boost::is_rvalue_reference<int>::type t55; +typedef boost::is_same<int, int>::type t56; +typedef boost::is_scalar<int>::type t57; +typedef boost::is_signed<int>::type t58; +typedef boost::is_stateless<int>::type t59; +typedef boost::is_union<int>::type t60; +typedef boost::is_unsigned<int>::type t61; +typedef boost::is_virtual_base_of<int, int>::type t62; +typedef boost::is_void<int>::type t63; +typedef boost::is_volatile<int>::type t64; +typedef boost::make_signed<int>::type t65; +typedef boost::make_unsigned<int>::type t66; +typedef boost::promote<int>::type t67; +typedef boost::rank<int>::type t68; + +typedef boost::remove_all_extents<int>::type t69; +typedef boost::remove_const<int>::type t70; +typedef boost::remove_cv<int>::type t71; +typedef boost::remove_extent<int>::type t72; +typedef boost::remove_pointer<int>::type t73; +typedef boost::remove_reference<int>::type t74; +typedef boost::remove_volatile<int>::type t75; +typedef boost::type_with_alignment<4>::type t76; + +int main() +{ + return 0; +} + + + + diff --git a/libs/type_traits/test/type_with_alignment_test.cpp b/libs/type_traits/test/type_with_alignment_test.cpp new file mode 100644 index 0000000000..65a9232c95 --- /dev/null +++ b/libs/type_traits/test/type_with_alignment_test.cpp @@ -0,0 +1,112 @@ + +// (C) Copyright John Maddock 2000. +// 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/alignment_of.hpp> +# include <boost/type_traits/type_with_alignment.hpp> +# include <boost/type_traits/is_pod.hpp> +#endif + +#if defined(BOOST_MSVC) || (defined(BOOST_INTEL) && defined(_MSC_VER)) +#if (_MSC_VER >= 1400) && defined(_M_IX86) +#include <xmmintrin.h> +#endif +struct __declspec(align(8)) a8 { char m[8]; }; +struct __declspec(align(16)) a16 { char m[16]; }; +struct __declspec(align(32)) a32 { char m[32]; }; +struct __declspec(align(64)) a64 { char m[64]; }; +struct __declspec(align(128)) a128 { char m[128]; }; +#endif + +void check_call2(...){} + +template <class T> +void check_call(const T& v) +{ + check_call2(v); +} + +#define TYPE_WITH_ALIGNMENT_TEST(T)\ +{\ +std::cout << "\ntesting type " << typeid(T).name() << std::endl;\ +std::cout << "Alignment of T is " << ::tt::alignment_of< T >::value << std::endl;\ +std::cout << "Aligned type is " << typeid(::tt::type_with_alignment< ::tt::alignment_of< T >::value>::type).name() << std::endl;\ +std::cout << "Alignment of aligned type is " << ::tt::alignment_of<\ + ::tt::type_with_alignment<\ + ::tt::alignment_of< T >::value\ + >::type\ +>::value << std::endl;\ +BOOST_CHECK(::tt::alignment_of<\ + ::tt::type_with_alignment<\ + ::tt::alignment_of< T >::value\ + >::type\ + >::value == ::boost::alignment_of< T >::value);\ +BOOST_CHECK(::tt::is_pod<\ + ::tt::type_with_alignment<\ + ::tt::alignment_of< T >::value>::type\ + >::value);\ +} +#define TYPE_WITH_ALIGNMENT_TEST_EX(T)\ + TYPE_WITH_ALIGNMENT_TEST(T)\ +{\ + ::tt::type_with_alignment<\ + ::tt::alignment_of< T >::value\ + >::type val;\ + check_call(val);\ +} + + +TT_TEST_BEGIN(type_with_alignment) + +TYPE_WITH_ALIGNMENT_TEST_EX(char) +TYPE_WITH_ALIGNMENT_TEST_EX(short) +TYPE_WITH_ALIGNMENT_TEST_EX(int) +TYPE_WITH_ALIGNMENT_TEST_EX(long) +TYPE_WITH_ALIGNMENT_TEST_EX(float) +TYPE_WITH_ALIGNMENT_TEST_EX(double) +TYPE_WITH_ALIGNMENT_TEST_EX(long double) + +#ifdef BOOST_HAS_LONG_LONG +TYPE_WITH_ALIGNMENT_TEST_EX(::boost::long_long_type) +#endif +#ifdef BOOST_HAS_MS_INT64 +TYPE_WITH_ALIGNMENT_TEST_EX(__int64) +#endif +TYPE_WITH_ALIGNMENT_TEST_EX(int[4]) +TYPE_WITH_ALIGNMENT_TEST_EX(int(*)(int)) +TYPE_WITH_ALIGNMENT_TEST_EX(int*) +TYPE_WITH_ALIGNMENT_TEST_EX(VB) +TYPE_WITH_ALIGNMENT_TEST_EX(VD) +TYPE_WITH_ALIGNMENT_TEST_EX(enum_UDT) +TYPE_WITH_ALIGNMENT_TEST_EX(mf2) +TYPE_WITH_ALIGNMENT_TEST_EX(POD_UDT) +TYPE_WITH_ALIGNMENT_TEST_EX(empty_UDT) +TYPE_WITH_ALIGNMENT_TEST_EX(union_UDT) + +#if defined(BOOST_MSVC) || (defined(BOOST_INTEL) && defined(_MSC_VER)) +#if (_MSC_VER >= 1400) && defined(_M_IX86) +TYPE_WITH_ALIGNMENT_TEST(__m128) +TYPE_WITH_ALIGNMENT_TEST(__m64) +#endif +TYPE_WITH_ALIGNMENT_TEST(a8) +TYPE_WITH_ALIGNMENT_TEST(a16) +TYPE_WITH_ALIGNMENT_TEST(a32) +#endif + +TT_TEST_END + + + + + + + + + diff --git a/libs/type_traits/test/udt_specialisations.cpp b/libs/type_traits/test/udt_specialisations.cpp new file mode 100644 index 0000000000..5636bfc350 --- /dev/null +++ b/libs/type_traits/test/udt_specialisations.cpp @@ -0,0 +1,48 @@ + +// (C) Copyright John Maddock 2004. +// 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_pod.hpp> +# include <boost/type_traits/is_class.hpp> +# include <boost/type_traits/is_union.hpp> +#endif + +struct my_pod{}; +struct my_union +{ + char c; + int i; +}; + +namespace tt +{ +template<> +struct is_pod<my_pod> + : public mpl::true_{}; +template<> +struct is_pod<my_union> + : public mpl::true_{}; +template<> +struct is_union<my_union> + : public mpl::true_{}; +template<> +struct is_class<my_union> + : public mpl::false_{}; +} + +TT_TEST_BEGIN(is_pod) + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<my_pod>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<my_union>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_union<my_union>::value, true); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_class<my_union>::value, false); + +TT_TEST_END + diff --git a/libs/type_traits/tools/specialisations.cpp b/libs/type_traits/tools/specialisations.cpp new file mode 100644 index 0000000000..f276bef5af --- /dev/null +++ b/libs/type_traits/tools/specialisations.cpp @@ -0,0 +1,122 @@ + +// (C) Copyright John Maddock 2000. +// 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) + +// +// Simple program to output some template specialisations for the type_traits library. +// + +#include <fstream> + +using namespace std; + +unsigned specializations = 30; + +int main() +{ + unsigned i, j; + ofstream os("specialisations"); + + // + // generate is_function tester prototypes: + for(i = 0; i <= specializations; ++i) + { + os << "template <class R"; + for(j = 0; j < i; ++j) + { + os << ", class A" << j; + } + os << ">\n::boost::type_traits::yes_type is_function_tester(R (*)("; + if(i == 0) + os << "void"; + else + { + for(j = 0; j < i; ++j) + { + if(j) os << ", "; + os << "A" << j; + } + } + os << "));" << endl; + } + os << endl << endl; + // + // generate is_function_helper partial specialisations: + // + for(i = 0; i < specializations; ++i) + { + os << "template <class R"; + for(j = 0; j < i; ++j) + { + os << ", class A" << j; + } + os << ">\nstruct is_function_helper_base<R (*)("; + if(i == 0) + os << "void"; + else + { + for(j = 0; j < i; ++j) + { + if(j) os << ", "; + os << "A" << j; + } + } + os << ")>{ BOOST_STATIC_CONSTANT(bool, value = true); };" << endl; + } + os << endl << endl; + + + // + // generate is_member_pointer_helper tester prototypes: + for(i = 0; i <= specializations; ++i) + { + os << "template <class R, class T"; + for(j = 0; j < i; ++j) + { + os << ", class A" << j; + } + os << ">\n::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)("; + if(i == 0) + os << "void"; + else + { + for(j = 0; j < i; ++j) + { + if(j) os << ", "; + os << "A" << j; + } + } + os << "));" << endl; + } + os << endl << endl; + // + // generate is_member_pointer partial specialisations: + // + for(i = 0; i < specializations; ++i) + { + os << "template <class R, class T"; + for(j = 0; j < i; ++j) + { + os << ", class A" << j; + } + os << ">\nstruct is_member_pointer<R (T::*)("; + if(i == 0) + os << "void"; + else + { + for(j = 0; j < i; ++j) + { + if(j) os << ", "; + os << "A" << j; + } + } + os << ")>{ BOOST_STATIC_CONSTANT(bool, value = true); };" << endl; + } + os << endl << endl; + + + return 0; +} + |