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

Removed is_abstract from this release, too many problems, too late in the day...

Browse Source 
[SVN r22106]
This commit is contained in:
John Maddock
2004-02-01 16:16:11 +00:00
parent 0a736faf65
commit 12f070b38e
4 changed files with 74 additions and 412 deletions
Download Patch File Download Diff File Expand all files Collapse all files

91
include/boost/type_traits/is_abstract.hpp
View File

@@ -1,91 +0,0 @@
#ifndef BOOST_TT_IS_ABSTRACT_CLASS_HPP
#define BOOST_TT_IS_ABSTRACT_CLASS_HPP
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
# pragma once
#endif
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
// is_abstract_class.hpp:
//
// (C) Copyright 2002 Rani Sharoni (rani_sharoni@hotmail.com) and Robert Ramey
// 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)
//
// See http://www.boost.org for updates, documentation, and revision history.
//
// Compile type discovery whether given type is abstract class or not.
//
// Requires DR 337 to be supported by compiler
// (http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/cwg_active.html#337).
//
//
// Believed (Jan 2004) to work on:
// - GCC 3.4
// - VC++ 7.1
// - compilers with new EDG frontend (Intel C++ 7, Comeau 4.3.2)
//
// Doesn't work on:
// - VC++6, VC++7.0 and less
// - GCC 3.3.X and less
// - Borland C++ 6 and less
//
//
// History:
// - Originally written by Rani Sharoni, see
// http://groups.google.com/groups?selm=df893da6.0207110613.75b2fe90%40posting.google.com
// At this time supported by EDG (Intel C++ 7, Comeau 4.3.2) and VC7.1.
// - Adapted and added into Boost.Serialization library by Robert Ramey
// (starting with submission #10).
// - Jan 2004: GCC 3.4 fixed to suport DR337 (Giovanni Bajo).
// - Jan 2004: modified to be part of Boost.TypeTraits (Pavel Vozenilek).
//
#include <boost/type_traits/detail/yes_no_type.hpp>
#include <boost/type_traits/is_class.hpp>
#include "boost/type_traits/detail/ice_and.hpp"
// should be the last #include
#include "boost/type_traits/detail/bool_trait_def.hpp"
namespace boost {
namespace detail{
template<class T>
struct is_abstract_imp
{
// Deduction fails if T is void, function type,
// reference type (14.8.2/2)or an abstract class type
// according to review status issue #337
//
template<class U>
static type_traits::no_type check(U (*)[1]);
template<class U>
static type_traits::yes_type check(...);
// GCC2 won't even parse this template if we embed the computation
// of s1 in the computation of value.
#ifdef __GNUC__
BOOST_STATIC_CONSTANT(unsigned, s1 = sizeof(is_abstract_imp<T>::template check<T>(0)));
#else
BOOST_STATIC_CONSTANT(unsigned, s1 = sizeof(check<T>(0)));
#endif
BOOST_STATIC_CONSTANT(bool, value =
(::boost::type_traits::ice_and<
::boost::is_class<T>::value,
(s1 == sizeof(type_traits::yes_type))
>::value));
};
}
BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_abstract,T,::boost::detail::is_abstract_imp<T>::value)
} // namespace boost
#include "boost/type_traits/detail/bool_trait_undef.hpp"
#endif //BOOST_TT_IS_ABSTRACT_CLASS_HPP

163
index.html
View File

@@ -298,20 +298,20 @@
</tr>
<tr>
<td valign="top" width="5%">&nbsp;</td>
<td valign="top" bgcolor="#c0c0c0"><code>::boost::alignment_of&lt;T&gt;::value</code></td>
<td valign="top" bgcolor="#c0c0c0">
<td valign="top" bgcolor="#c0c0c0"><code>::boost::alignment_of&lt;T&gt;::value</code></td>
<td valign="top" bgcolor="#c0c0c0">
<P>Identifies the alignment requirements of T. Actually returns a value that is
only guaranteed to be a multiple of the actual alignment requirements of T.</P>
<P>T must be a complete type.</P>
</td>
<td valign="top" bgcolor="#c0c0c0">&nbsp;</td>
<td valign="top" bgcolor="#c0c0c0">&nbsp;</td>
<td valign="top" bgcolor="#c0c0c0">&nbsp;</td>
<td valign="top" bgcolor="#c0c0c0">&nbsp;</td>
<td valign="top" width="5%">&nbsp;</td>
</tr>
<tr>
<td valign="top" width="5%">&nbsp;</td>
<td valign="top" bgcolor="#c0c0c0"><code>::boost::is_empty&lt;T&gt;::value</code></td>
<td valign="top" bgcolor="#c0c0c0">
<td valign="top" bgcolor="#c0c0c0"><code>::boost::is_empty&lt;T&gt;::value</code></td>
<td valign="top" bgcolor="#c0c0c0">
<P>True if T is an empty struct or class. If the compiler implements the "zero
sized empty base classes" optimisation, then is_empty will correctly guess
whether T is empty. Relies upon is_class to determine whether T is a class
@@ -319,9 +319,9 @@
</P>
<P>T must be a complete type.</P>
</td>
<td valign="top" bgcolor="#c0c0c0"><p align="center">10p5</p>
<td valign="top" bgcolor="#c0c0c0"><p align="center">10p5</p>
</td>
<td valign="top" bgcolor="#c0c0c0"><p align="left">Relies on the compiler
<td valign="top" bgcolor="#c0c0c0"><p align="left">Relies on the compiler
implementing zero sized empty base classes in order to detect empty classes.
</p>
<p align="left">Can not be used with incomplete types.</p>
@@ -334,75 +334,63 @@
</tr>
<tr>
<td valign="top" width="5%">&nbsp;</td>
<td valign="top" bgcolor="#c0c0c0"><code>::boost::is_const&lt;T&gt;::value</code></td>
<td valign="top" bgcolor="#c0c0c0">Evaluates to true only if T is
top-level const-qualified.</td>
<td valign="top" bgcolor="#c0c0c0"><p align="center">3.9.3</p>
<td valign="top" bgcolor="#c0c0c0"><code>::boost::is_const&lt;T&gt;::value</code></td>
<td valign="top" bgcolor="#c0c0c0">Evaluates to true only if T is top-level
const-qualified.</td>
<td valign="top" bgcolor="#c0c0c0"><p align="center">3.9.3</p>
</td>
<td valign="top" bgcolor="#c0c0c0">&nbsp;</td>
<td valign="top" bgcolor="#c0c0c0">&nbsp;</td>
<td valign="top" width="5%">&nbsp;</td>
</tr>
<tr>
<td valign="top" width="5%">&nbsp;</td>
<td valign="top" bgcolor="#c0c0c0"><code>::boost::is_volatile&lt;T&gt;::value</code></td>
<td valign="top" bgcolor="#c0c0c0">Evaluates to true only if T is
<td valign="top" bgcolor="#c0c0c0"><code>::boost::is_volatile&lt;T&gt;::value</code></td>
<td valign="top" bgcolor="#c0c0c0">Evaluates to true only if T is
volatile-qualified.</td>
<td valign="top" bgcolor="#c0c0c0"><p align="center">3.9.3</p>
<td valign="top" bgcolor="#c0c0c0"><p align="center">3.9.3</p>
</td>
<td valign="top" bgcolor="#c0c0c0">&nbsp;</td>
<td valign="top" width="5%">&nbsp;</td>
</tr>
<TR>
<TD vAlign="top" width="5%"></TD>
<TD vAlign="top" bgColor="#c0c0c0">::boost::is_abstract&lt;T&gt;::value</TD>
<TD vAlign="top" bgColor="#c0c0c0">Evaluates true only if T is
abstract class.</TD>
<TD vAlign="top" bgColor="#c0c0c0">10.3</TD>
<TD vAlign="top" bgColor="#c0c0c0">Compiler must support DR337 (as Jan
2004: GCC 3.4,<BR>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; VC++ 7.1, Intel C++ 7, Comeau 4.3.2).</TD>
<TD vAlign="top" width="5%"></TD>
</TR>
<tr>
<td valign="top" width="5%">&nbsp;</td>
<td valign="top" bgcolor="#c0c0c0"><code>::boost::is_polymorphic&lt;T&gt;::value</code></td>
<td valign="top" bgcolor="#c0c0c0">Evaluates to true only if T is a
polymorphic type.
<P>T must be a complete type.</P>
</td>
<td valign="top" bgcolor="#c0c0c0">10.3</td>
<td valign="top" bgcolor="#c0c0c0">Requires knowledge of the compilers
ABI, does actually seem to work with the majority of compilers though.</td>
<td valign="top" bgcolor="#c0c0c0">&nbsp;</td>
<td valign="top" width="5%">&nbsp;</td>
</tr>
<tr>
<td valign="top" width="5%">&nbsp;</td>
<td valign="top" bgcolor="#c0c0c0"><code>::boost::is_pod&lt;T&gt;::value</code></td>
<td valign="top" bgcolor="#c0c0c0">Evaluates to true only if T is a
cv-qualified POD type.
<td valign="top" bgcolor="#c0c0c0"><code>::boost::is_polymorphic&lt;T&gt;::value</code></td>
<td valign="top" bgcolor="#c0c0c0">Evaluates to true only if T is a polymorphic
type.
<P>T must be a complete type.</P>
</td>
<td valign="top" bgcolor="#c0c0c0"><p align="center">3.9p10</p>
<td valign="top" bgcolor="#c0c0c0">10.3</td>
<td valign="top" bgcolor="#c0c0c0">Requires knowledge of the compilers ABI, does
actually seem to work with the majority of compilers though.</td>
<td valign="top" width="5%">&nbsp;</td>
</tr>
<tr>
<td valign="top" width="5%">&nbsp;</td>
<td valign="top" bgcolor="#c0c0c0"><code>::boost::is_pod&lt;T&gt;::value</code></td>
<td valign="top" bgcolor="#c0c0c0">Evaluates to true only if T is a cv-qualified
POD type.
<P>T must be a complete type.</P>
</td>
<td valign="top" bgcolor="#c0c0c0"><p align="center">3.9p10</p>
<p align="center">9p4</p>
</td>
<td valign="top" bgcolor="#c0c0c0">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.<p>If the compiler does not
support partial-specialization of class templates, then this template can not
be used with function types.</p>
<td valign="top" bgcolor="#c0c0c0">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.<p>If the compiler does not support
partial-specialization of class templates, then this template can not be used
with function types.</p>
</td>
<td valign="top" width="5%">&nbsp;</td>
</tr>
<tr>
<td valign="top" width="5%">&nbsp;</td>
<td valign="top" bgcolor="#c0c0c0"><code>::boost::has_trivial_constructor&lt;T&gt;::value</code></td>
<td valign="top" bgcolor="#c0c0c0">True if T has a trivial default
constructor.</td>
<td valign="top" bgcolor="#c0c0c0">12.1p5</td>
<td valign="top" bgcolor="#c0c0c0"><p align="left">Without some (as yet
unspecified) help from the compiler, <code>has_trivial_constructor </code>will
never report that a class or struct has a trivial constructor; this is always
safe, if possibly sub-optimal.</p>
<td valign="top" bgcolor="#c0c0c0"><code>::boost::has_trivial_constructor&lt;T&gt;::value</code></td>
<td valign="top" bgcolor="#c0c0c0">True if T has a trivial default constructor.</td>
<td valign="top" bgcolor="#c0c0c0">12.1p5</td>
<td valign="top" bgcolor="#c0c0c0"><p align="left">Without some (as yet unspecified)
help from the compiler, <code>has_trivial_constructor </code>will never report
that a class or struct has a trivial constructor; this is always safe, if
possibly sub-optimal.</p>
<p>If the compiler does not support partial-specialization of class templates,
then this template can not be used with function types.</p>
</td>
@@ -410,16 +398,15 @@
</tr>
<tr>
<td valign="top" width="5%">&nbsp;</td>
<td valign="top" bgcolor="#c0c0c0"><code>::boost::has_trivial_copy&lt;T&gt;::value</code></td>
<td valign="top" bgcolor="#c0c0c0">True if T has a trivial copy
constructor.
<td valign="top" bgcolor="#c0c0c0"><code>::boost::has_trivial_copy&lt;T&gt;::value</code></td>
<td valign="top" bgcolor="#c0c0c0">True if T has a trivial copy constructor.
<P>T must be a complete type.</P>
</td>
<td valign="top" bgcolor="#c0c0c0">12.8p6</td>
<td valign="top" bgcolor="#c0c0c0"><p align="left">Without some (as yet
unspecified) help from the compiler, <code>has_trivial_copy </code>will never
report that a class or struct has a trivial copy constructor; this is always
safe, if possibly sub-optimal.</p>
<td valign="top" bgcolor="#c0c0c0">12.8p6</td>
<td valign="top" bgcolor="#c0c0c0"><p align="left">Without some (as yet unspecified)
help from the compiler, <code>has_trivial_copy </code>will never report that a
class or struct has a trivial copy constructor; this is always safe, if
possibly sub-optimal.</p>
<p>If the compiler does not support partial-specialization of class templates,
then this template can not be used with function types.</p>
</td>
@@ -427,16 +414,15 @@
</tr>
<tr>
<td valign="top" width="5%">&nbsp;</td>
<td valign="top" bgcolor="#c0c0c0"><code>::boost::has_trivial_assign&lt;T&gt;::value</code></td>
<td valign="top" bgcolor="#c0c0c0">True if T has a trivial assignment
operator.
<td valign="top" bgcolor="#c0c0c0"><code>::boost::has_trivial_assign&lt;T&gt;::value</code></td>
<td valign="top" bgcolor="#c0c0c0">True if T has a trivial assignment operator.
<P>T must be a complete type.</P>
</td>
<td valign="top" bgcolor="#c0c0c0">12.8p11</td>
<td valign="top" bgcolor="#c0c0c0"><p align="left">Without some (as yet
unspecified) help from the compiler, <code>has_trivial_assign </code>will never
report that a class or struct has a trivial assignment operator; this is always
safe, if possibly sub-optimal.</p>
<td valign="top" bgcolor="#c0c0c0">12.8p11</td>
<td valign="top" bgcolor="#c0c0c0"><p align="left">Without some (as yet unspecified)
help from the compiler, <code>has_trivial_assign </code>will never report that
a class or struct has a trivial assignment operator; this is always safe, if
possibly sub-optimal.</p>
<p>If the compiler does not support partial-specialization of class templates,
then this template can not be used with function types.</p>
</td>
@@ -444,15 +430,15 @@
</tr>
<tr>
<td valign="top" width="5%">&nbsp;</td>
<td valign="top" bgcolor="#c0c0c0"><code>::boost::has_trivial_destructor&lt;T&gt;::value</code></td>
<td valign="top" bgcolor="#c0c0c0">True if T has a trivial destructor.
<td valign="top" bgcolor="#c0c0c0"><code>::boost::has_trivial_destructor&lt;T&gt;::value</code></td>
<td valign="top" bgcolor="#c0c0c0">True if T has a trivial destructor.
<P>T must be a complete type.</P>
</td>
<td valign="top" bgcolor="#c0c0c0">12.4p3</td>
<td valign="top" bgcolor="#c0c0c0"><p align="left">Without some (as yet
unspecified) help from the compiler, <code>has_trivial_destructor </code>will
never report that a class or struct has a trivial destructor; this is always
safe, if possibly sub-optimal.</p>
<td valign="top" bgcolor="#c0c0c0">12.4p3</td>
<td valign="top" bgcolor="#c0c0c0"><p align="left">Without some (as yet unspecified)
help from the compiler, <code>has_trivial_destructor </code>will never report
that a class or struct has a trivial destructor; this is always safe, if
possibly sub-optimal.</p>
<p>If the compiler does not support partial-specialization of class templates,
then this template can not be used with function types.</p>
</td>
@@ -460,16 +446,15 @@
</tr>
<tr>
<td valign="top" width="5%">&nbsp;</td>
<td valign="top" bgcolor="#c0c0c0"><code>::boost::is_stateless&lt;T&gt;::value</code></td>
<td valign="top" bgcolor="#c0c0c0">True if T is stateless, meaning
that T has no storage and its constructors and destructors are trivial.
<td valign="top" bgcolor="#c0c0c0"><code>::boost::is_stateless&lt;T&gt;::value</code></td>
<td valign="top" bgcolor="#c0c0c0">True if T is stateless, meaning that T has no
storage and its constructors and destructors are trivial.
<P>T must be a complete type.</P>
</td>
<td valign="top" bgcolor="#c0c0c0">&nbsp;</td>
<td valign="top" bgcolor="#c0c0c0"><p align="left">Without some (as yet
unspecified) help from the compiler, <code>is_stateless </code>will never
report that a class or struct is_stateless; this is always safe, if possibly
sub-optimal.</p>
<td valign="top" bgcolor="#c0c0c0">&nbsp;</td>
<td valign="top" bgcolor="#c0c0c0"><p align="left">Without some (as yet unspecified)
help from the compiler, <code>is_stateless </code>will never report that a
class or struct is_stateless; this is always safe, if possibly sub-optimal.</p>
<p align="left">Will report true only if all of the following also report true:</p>
<div align="left"><pre>::boost::has_trivial_constructor&lt;T&gt;::value,
::boost::has_trivial_copy&lt;T&gt;::value,
@@ -688,7 +673,7 @@ bool const y = boost::is_convertible&lt;D*,A*&gt;::value; // error
<td valign="top" width="13%" bgcolor="#c0c0c0">8.3.4</td>
<td width="25%" bgcolor="#c0c0c0"><p align="left">If the compiler does not support
partial-specialization of class templates, then this template will compile, but
will have no effect, except where noted below.</p>
will have no effect.</p>
</td>
<td valign="top" width="5%">&nbsp;</td>
</tr>

1
test/Jamfile
View File

@@ -45,7 +45,6 @@ test-suite type_traits :
[ type-traits-run has_trivial_constr_test.cpp ]
[ type-traits-run has_trivial_copy_test.cpp ]
[ type-traits-run has_trivial_destructor_test.cpp ]
[ type-traits-run is_abstract_test.cpp ]
[ type-traits-run is_arithmetic_test.cpp ]
[ type-traits-run is_array_test.cpp ]
[ type-traits-run is_base_and_derived_test.cpp ]

231
test/is_abstract_test.cpp
View File

@@ -1,231 +0,0 @@
// (C) Copyright Rani Sharoni,Robert Ramey and Pavel Vozenilek 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
struct TestA {};
struct TestB { virtual void foo(void) = 0; };
struct TestC { private: virtual void foo(void) = 0; };
struct TestD : TestA {};
struct TestE : TestB {};
struct TestF : TestC {};
struct TestG : TestB { virtual void foo(void) {} };
struct TestH : TestC { private: virtual void foo(void) {} };
struct TestI : TestB, TestC {};
struct TestJ : TestI { virtual void foo(void) {} };
struct TestK : TestB { virtual void foo(void); virtual void foo2(void) = 0; };
struct TestL : TestK { virtual void foo2(void) {} };
struct TestM : virtual TestB {};
struct TestN : virtual TestC {};
struct TestO : TestM, TestN {};
struct TestP : TestO { virtual void foo(void) {} };
struct TestQ : TestB { virtual void foo(void) = 0; };
struct TestR : TestC { private: virtual void foo(void) = 0; };
struct TestS { virtual void foo(void) {} };
struct TestT { virtual ~TestT(void) {} virtual void foo(void) {} };
struct TestU : TestT { virtual void foo(void) = 0; };
struct TestV : TestT { virtual void foo(void) {} };
struct TestW { virtual void foo1(void) = 0; virtual void foo2(void) = 0; };
struct TestX : 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 : TestZ { virtual ~TestAA(void) = 0; }; TestAA::~TestAA(void) {}
struct TestAB : TestAA { virtual ~TestAB(void) {} };
struct TestAC { virtual void foo(void) = 0; }; void TestAC::foo(void) {}
struct TestAD : TestAC {};
struct TestAE : TestAD { virtual void foo() {} };
struct TestAF : TestAD { virtual void foo(); }; void TestAF::foo(void) {}
struct TestAG : virtual TestA {};
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);
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);
TT_TEST_END