mirror of
https://github.com/boostorg/static_assert.git
synced 2025-12-26 16:58:14 +01:00
Compare commits
2 Commits
boost-1.90
...
develop
| Author | SHA1 | Date | |
|---|---|---|---|
|
aea95895f4 | ||
|
4cc0d67e50 |
@@ -11,8 +11,6 @@ project(boost_static_assert VERSION "${BOOST_SUPERPROJECT_VERSION}" LANGUAGES CX
|
||||
add_library(boost_static_assert INTERFACE)
|
||||
add_library(Boost::static_assert ALIAS boost_static_assert)
|
||||
|
||||
target_include_directories(boost_static_assert INTERFACE include)
|
||||
|
||||
target_link_libraries(boost_static_assert
|
||||
INTERFACE
|
||||
Boost::config
|
||||
|
||||
31
README.md
31
README.md
@@ -4,33 +4,4 @@ Boost StaticAssert Library
|
||||
The Boost StaticAssert library provides static assertions for C++, this library is the ancestor to C++ native static_assert's and
|
||||
can be used on older compilers which don't have that feature.
|
||||
|
||||
The full documentation is available on [boost.org](http://www.boost.org/doc/libs/release/libs/static_assert).
|
||||
|
||||
## Support, bugs and feature requests ##
|
||||
|
||||
Bugs and feature requests can be reported through the [Gitub issue tracker](https://github.com/boostorg/static_assert/issues)
|
||||
(see [open issues](https://github.com/boostorg/static_assert/issues) and
|
||||
[closed issues](https://github.com/boostorg/static_assert/issues?utf8=%E2%9C%93&q=is%3Aissue+is%3Aclosed)).
|
||||
|
||||
You can submit your changes through a [pull request](https://github.com/boostorg/static_assert/pulls).
|
||||
|
||||
There is no mailing-list specific to Boost StaticAssert, although you can use the general-purpose Boost [mailing-list](http://lists.boost.org/mailman/listinfo.cgi/boost-users) using the tag [static_assert].
|
||||
|
||||
|
||||
## Development ##
|
||||
|
||||
Clone the whole boost project, which includes the individual Boost projects as submodules ([see boost+git doc](https://github.com/boostorg/boost/wiki/Getting-Started)):
|
||||
|
||||
git clone https://github.com/boostorg/boost
|
||||
cd boost
|
||||
git submodule update --init
|
||||
|
||||
The Boost StaticAssert Library is located in `libs/static_assert/`.
|
||||
|
||||
### Running tests ###
|
||||
First, make sure you are in `libs/static_assert/test`.
|
||||
You can either run all the tests listed in `Jamfile.v2` or run a single test:
|
||||
|
||||
../../../b2 <- run all tests
|
||||
../../../b2 static_assert_test <- single test
|
||||
|
||||
This library has been merged into [Boost.Config](https://github.com/boostorg/config). The full documentation is available on [boost.org](https://www.boost.org/doc/libs/release/libs/config).
|
||||
|
||||
@@ -1,49 +0,0 @@
|
||||
|
||||
# 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)
|
||||
|
||||
using quickbook ;
|
||||
|
||||
path-constant boost-images : ../../../doc/src/images ;
|
||||
|
||||
xml static_assert : static_assert.qbk ;
|
||||
boostbook standalone
|
||||
:
|
||||
static_assert
|
||||
:
|
||||
<xsl:param>boost.root=../../../..
|
||||
<xsl:param>nav.layout=none
|
||||
<xsl:param>navig.graphics=0
|
||||
# PDF Options:
|
||||
# TOC Generation: this is needed for FOP-0.9 and later:
|
||||
<xsl:param>fop1.extensions=0
|
||||
# Or enable this if you're using XEP:
|
||||
<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
|
||||
# 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/doc/html
|
||||
;
|
||||
|
||||
###############################################################################
|
||||
alias boostdoc
|
||||
: static_assert
|
||||
:
|
||||
:
|
||||
: ;
|
||||
explicit boostdoc ;
|
||||
alias boostrelease ;
|
||||
explicit boostrelease ;
|
||||
@@ -1,243 +0,0 @@
|
||||
[library Boost.StaticAssert
|
||||
[copyright 2000 2005 Steve Cleary and John Maddock]
|
||||
[purpose Compile time diagnostics library]
|
||||
[license
|
||||
Distributed under the Boost Software License, Version 1.0.
|
||||
(See accompanying file LICENSE_1_0.txt or copy at
|
||||
<ulink url="http://www.boost.org/LICENSE_1_0.txt">
|
||||
http://www.boost.org/LICENSE_1_0.txt
|
||||
</ulink>)
|
||||
]
|
||||
[authors [Maddock, John], [Cleary, Steve]]
|
||||
[category template]
|
||||
[category testing]
|
||||
[category generic]
|
||||
[last-revision $Date$]
|
||||
]
|
||||
|
||||
This manual is also available in
|
||||
[@http://sourceforge.net/projects/boost/files/boost-docs/
|
||||
printer friendly PDF format].
|
||||
|
||||
[section:intro Overview and Tutorial]
|
||||
|
||||
The header `<boost/static_assert.hpp>` supplies two macros:
|
||||
|
||||
BOOST_STATIC_ASSERT(x)
|
||||
BOOST_STATIC_ASSERT_MSG(x, msg)
|
||||
|
||||
Both generate a compile time error message if the integral-constant-expression `x`
|
||||
is not true. In other words, they are the compile time equivalent of the assert macro;
|
||||
this is sometimes known as a "compile-time-assertion", but will be called a
|
||||
"static assertion" throughout these docs. Note that if the condition is `true`,
|
||||
then the macros will generate neither code nor data - and the macros can also
|
||||
be used at either namespace, class or function scope. When used in a template,
|
||||
the static assertion will be evaluated at the time the template is instantiated;
|
||||
this is particularly useful for validating template parameters.
|
||||
|
||||
If the C++0x `static_assert` feature is available, both macros will use it.
|
||||
For `BOOST_STATIC_ASSERT(x)`, the error message will be a stringized version of `x`.
|
||||
For `BOOST_STATIC_ASSERT_MSG(x, msg)`, the error message will be the `msg` string.
|
||||
|
||||
If the C++0x `static_assert` feature is not available, `BOOST_STATIC_ASSERT_MSG(x, msg)`
|
||||
will be treated as `BOOST_STATIC_ASSERT(x)`.
|
||||
|
||||
The material that follows assumes the C++0x `static_assert` feature is not available.
|
||||
|
||||
One of the aims of `BOOST_STATIC_ASSERT` is to generate readable error messages.
|
||||
These immediately tell the user that a library is being used in a manner that
|
||||
is not supported. While error messages obviously differ from compiler to compiler,
|
||||
but you should see something like:
|
||||
|
||||
Illegal use of STATIC_ASSERTION_FAILURE<false>
|
||||
|
||||
Which is intended to at least catch the eye!
|
||||
|
||||
You can use `BOOST_STATIC_ASSERT` at any place where you can place a declaration,
|
||||
that is at class, function or namespace scope, this is illustrated by the
|
||||
following examples:
|
||||
|
||||
[section:namespace Use at namespace scope.]
|
||||
|
||||
The macro can be used at namespace scope, if there is some requirement must
|
||||
always be true; generally this means some platform specific requirement.
|
||||
Suppose we require that `int` be at least a 32-bit integral type, and that `wchar_t`
|
||||
be an unsigned type. We can verify this at compile time as follows:
|
||||
|
||||
#include <climits>
|
||||
#include <cwchar>
|
||||
#include <limits>
|
||||
#include <boost/static_assert.hpp>
|
||||
|
||||
namespace my_conditions {
|
||||
|
||||
BOOST_STATIC_ASSERT(std::numeric_limits<int>::digits >= 32);
|
||||
BOOST_STATIC_ASSERT(WCHAR_MIN >= 0);
|
||||
|
||||
} // namespace my_conditions
|
||||
|
||||
The use of the namespace my_conditions here requires some comment.
|
||||
The macro `BOOST_STATIC_ASSERT` works by generating an typedef declaration,
|
||||
and since the typedef must have a name, the macro generates one automatically by
|
||||
mangling a stub name with the value of `__LINE__`. When `BOOST_STATIC_ASSERT` is
|
||||
used at either class or function scope then each use of `BOOST_STATIC_ASSERT`
|
||||
is guaranteed to produce a name unique to that scope (provided you only use
|
||||
the macro once on each line). However when used in a header at namespace
|
||||
scope, that namespace can be continued over multiple headers, each of which
|
||||
may have their own static assertions, and on the "same" lines, thereby generating
|
||||
duplicate declarations. In theory the compiler should silently ignore duplicate
|
||||
typedef declarations, however many do not do so (and even if they do they are
|
||||
entitled to emit warnings in such cases). To avoid potential problems, if you
|
||||
use `BOOST_STATIC_ASSERT` in a header and at namespace scope, then enclose
|
||||
them in a namespace unique to that header.
|
||||
|
||||
[endsect]
|
||||
|
||||
[section:function Use at function scope]
|
||||
|
||||
The macro is typically used at function scope inside template functions,
|
||||
when the template arguments need checking. Imagine that we have an
|
||||
iterator-based algorithm that requires random access iterators.
|
||||
If the algorithm is instantiated with iterators that do not meet our
|
||||
requirements then an error will be generated eventually, but this may
|
||||
be nested deep inside several templates, making it hard for the user to
|
||||
determine what went wrong. One option is to add a static assertion at
|
||||
the top level of the template, in that case if the condition is not met,
|
||||
then an error will be generated in a way that makes it reasonably obvious to
|
||||
the user that the template is being misused.
|
||||
|
||||
#include <iterator>
|
||||
#include <boost/static_assert.hpp>
|
||||
#include <boost/type_traits.hpp>
|
||||
|
||||
template <class RandomAccessIterator >
|
||||
RandomAccessIterator foo(RandomAccessIterator from,
|
||||
RandomAccessIterator to)
|
||||
{
|
||||
// this template can only be used with
|
||||
// random access iterators...
|
||||
typedef typename std::iterator_traits<
|
||||
RandomAccessIterator >::iterator_category cat;
|
||||
BOOST_STATIC_ASSERT(
|
||||
(boost::is_convertible<
|
||||
cat,
|
||||
const std::random_access_iterator_tag&>::value));
|
||||
//
|
||||
// detail goes here...
|
||||
return from;
|
||||
}
|
||||
|
||||
A couple of footnotes are in order here: the extra set of parenthesis around the
|
||||
assert, is to prevent the comma inside the `is_convertible` template being
|
||||
interpreted by the preprocessor as a macro argument separator; the target type
|
||||
for `is_convertible` is a reference type, as some compilers have problems
|
||||
using `is_convertible` when the conversion is via a user defined constructor
|
||||
(in any case there is no guarantee that the iterator tag classes are
|
||||
copy-constructible).
|
||||
|
||||
[endsect]
|
||||
|
||||
[section:class Use at class scope]
|
||||
|
||||
The macro is typically used inside classes that are templates.
|
||||
Suppose we have a template-class that requires an unsigned integral type with
|
||||
at least 16-bits of precision as a template argument, we can achieve this
|
||||
using something like this:
|
||||
|
||||
#include <limits>
|
||||
#include <boost/static_assert.hpp>
|
||||
|
||||
template <class UnsignedInt>
|
||||
class myclass
|
||||
{
|
||||
private:
|
||||
BOOST_STATIC_ASSERT_MSG(std::numeric_limits<UnsignedInt>::is_specialized, "myclass can only be specialized for types with numeric_limits support.");
|
||||
BOOST_STATIC_ASSERT_MSG(std::numeric_limits<UnsignedInt>::digits >= 16, "Template argument UnsignedInt must have at least 16 bits precision.")
|
||||
BOOST_STATIC_ASSERT_MSG(std::numeric_limits<UnsignedInt>::is_integer, "Template argument UnsignedInt must be an integer.");
|
||||
BOOST_STATIC_ASSERT_MSG(!std::numeric_limits<UnsignedInt>::is_signed, "Template argument UnsignedInt must not be signed.");
|
||||
public:
|
||||
/* details here */
|
||||
};
|
||||
|
||||
[endsect]
|
||||
|
||||
[section:templates Use in templates]
|
||||
|
||||
Normally static assertions when used inside a class or function template,
|
||||
will not be instantiated until the template in which it is used is instantiated.
|
||||
However, there is one potential problem to watch out for: if the static assertion
|
||||
is not dependent upon one or more template parameters, then the compiler is
|
||||
permitted to evaluate the static assertion at the point it is first seen,
|
||||
irrespective of whether the template is ever instantiated, for example:
|
||||
|
||||
template <class T>
|
||||
struct must_not_be_instantiated
|
||||
{
|
||||
BOOST_STATIC_ASSERT(false);
|
||||
};
|
||||
|
||||
Will produce a compiler error with some compilers (for example Intel 8.1
|
||||
or gcc 3.4), regardless of whether the template is ever instantiated. A
|
||||
workaround in cases like this is to force the assertion to be dependent
|
||||
upon a template parameter:
|
||||
|
||||
template <class T>
|
||||
struct must_not_be_instantiated
|
||||
{
|
||||
// this will be triggered if this type is instantiated
|
||||
BOOST_STATIC_ASSERT(sizeof(T) == 0);
|
||||
};
|
||||
|
||||
|
||||
[endsect]
|
||||
|
||||
[endsect]
|
||||
|
||||
[section:how How it works]
|
||||
|
||||
`BOOST_STATIC_ASSERT` works as follows. There is class `STATIC_ASSERTION_FAILURE`
|
||||
which is defined as:
|
||||
|
||||
namespace boost{
|
||||
|
||||
template <bool> struct STATIC_ASSERTION_FAILURE;
|
||||
|
||||
template <> struct STATIC_ASSERTION_FAILURE<true>{};
|
||||
|
||||
}
|
||||
|
||||
The key feature is that the error message triggered by the undefined
|
||||
expression `sizeof(STATIC_ASSERTION_FAILURE<0>)`, tends to be consistent
|
||||
across a wide variety of compilers. The rest of the machinery of
|
||||
`BOOST_STATIC_ASSERT` is just a way to feed the `sizeof` expression into a `typedef`.
|
||||
The use of a macro here is somewhat ugly; however boost members have spent
|
||||
considerable effort trying to invent a static assert that avoided macros,
|
||||
all to no avail. The general conclusion was that the good of a static assert
|
||||
working at namespace, function, and class scope outweighed the ugliness of a macro.
|
||||
|
||||
[endsect]
|
||||
|
||||
[section:test Test Programs]
|
||||
|
||||
[table Test programs provided with static_assert
|
||||
[[Test Program][Expected to Compile][Description]]
|
||||
|
||||
[[[@../../libs/static_assert/example/static_assert_example_1.cpp static_assert_example_1.cpp]] [Platform dependent.] [Namespace scope test program, may compile depending upon the platform. ]]
|
||||
[[[@../../libs/static_assert/example/static_assert_example_2.cpp static_assert_example_2.cpp]] [Yes] [Function scope test program. ]]
|
||||
[[[@../../libs/static_assert/example/static_assert_example_3.cpp static_assert_example_3.cpp]] [Yes] [Class scope test program. ]]
|
||||
[[[@../../libs/static_assert/test/static_assert_test.cpp static_assert_test.cpp]] [Yes] [Illustrates usage, and should always compile, really just tests compiler compatibility.]]
|
||||
[[[@../../libs/static_assert/test/static_assert_test_fail_1.cpp static_assert_test_fail_1.cpp]] [No] [Illustrates failure at namespace scope. ]]
|
||||
[[[@../../libs/static_assert/test/static_assert_test_fail_2.cpp static_assert_test_fail_2.cpp]] [No] [Illustrates failure at non-template function scope. ]]
|
||||
[[[@../../libs/static_assert/test/static_assert_test_fail_3.cpp static_assert_test_fail_3.cpp]] [No] [Illustrates failure at non-template class scope. ]]
|
||||
[[[@../../libs/static_assert/test/static_assert_test_fail_4.cpp static_assert_test_fail_4.cpp]] [No] [Illustrates failure at non-template class scope. ]]
|
||||
[[[@../../libs/static_assert/test/static_assert_test_fail_5.cpp static_assert_test_fail_5.cpp]] [No] [Illustrates failure at template class scope. ]]
|
||||
[[[@../../libs/static_assert/test/static_assert_test_fail_6.cpp static_assert_test_fail_6.cpp]] [No] [Illustrates failure at template class member function scope. ]]
|
||||
[[[@../../libs/static_assert/test/static_assert_test_fail_7.cpp static_assert_test_fail_7.cpp]] [No] [Illustrates failure of class scope example. ]]
|
||||
[[[@../../libs/static_assert/test/static_assert_test_fail_8.cpp static_assert_test_fail_8.cpp]] [No] [Illustrates failure of function scope example. ]]
|
||||
[[[@../../libs/static_assert/test/static_assert_test_fail_9.cpp static_assert_test_fail_9.cpp]] [No] [Illustrates failure of function scope example (part 2). ]]
|
||||
|
||||
]
|
||||
|
||||
[endsect]
|
||||
|
||||
|
||||
@@ -1,181 +0,0 @@
|
||||
// (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)
|
||||
|
||||
// See http://www.boost.org/libs/static_assert for documentation.
|
||||
|
||||
/*
|
||||
Revision history:
|
||||
02 August 2000
|
||||
Initial version.
|
||||
*/
|
||||
|
||||
#ifndef BOOST_STATIC_ASSERT_HPP
|
||||
#define BOOST_STATIC_ASSERT_HPP
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/detail/workaround.hpp>
|
||||
#include <cstddef> //for std::size_t
|
||||
|
||||
#if defined(__GNUC__) && !defined(__GXX_EXPERIMENTAL_CXX0X__)
|
||||
//
|
||||
// This is horrible, but it seems to be the only we can shut up the
|
||||
// "anonymous variadic macros were introduced in C99 [-Wvariadic-macros]"
|
||||
// warning that get spewed out otherwise in non-C++11 mode.
|
||||
//
|
||||
#pragma GCC system_header
|
||||
#endif
|
||||
|
||||
#ifndef BOOST_NO_CXX11_STATIC_ASSERT
|
||||
# ifndef BOOST_NO_CXX11_VARIADIC_MACROS
|
||||
# define BOOST_STATIC_ASSERT_MSG( ... ) static_assert(__VA_ARGS__)
|
||||
# else
|
||||
# define BOOST_STATIC_ASSERT_MSG( B, Msg ) static_assert( B, Msg )
|
||||
# endif
|
||||
#else
|
||||
# define BOOST_STATIC_ASSERT_MSG( B, Msg ) BOOST_STATIC_ASSERT( B )
|
||||
#endif
|
||||
|
||||
#ifdef BOOST_BORLANDC
|
||||
//
|
||||
// workaround for buggy integral-constant expression support:
|
||||
#define BOOST_BUGGY_INTEGRAL_CONSTANT_EXPRESSIONS
|
||||
#endif
|
||||
|
||||
#if defined(__GNUC__) && (__GNUC__ == 3) && ((__GNUC_MINOR__ == 3) || (__GNUC_MINOR__ == 4))
|
||||
// gcc 3.3 and 3.4 don't produce good error messages with the default version:
|
||||
# define BOOST_SA_GCC_WORKAROUND
|
||||
#endif
|
||||
|
||||
//
|
||||
// If the compiler issues warnings about old C style casts,
|
||||
// then enable this:
|
||||
//
|
||||
#if defined(__GNUC__) && ((__GNUC__ > 3) || ((__GNUC__ == 3) && (__GNUC_MINOR__ >= 4)))
|
||||
# ifndef BOOST_NO_CXX11_VARIADIC_MACROS
|
||||
# define BOOST_STATIC_ASSERT_BOOL_CAST( ... ) ((__VA_ARGS__) != 0)
|
||||
# else
|
||||
# define BOOST_STATIC_ASSERT_BOOL_CAST( x ) ((x) != 0)
|
||||
# endif
|
||||
#else
|
||||
# ifndef BOOST_NO_CXX11_VARIADIC_MACROS
|
||||
# define BOOST_STATIC_ASSERT_BOOL_CAST( ... ) (bool)(__VA_ARGS__)
|
||||
# else
|
||||
# define BOOST_STATIC_ASSERT_BOOL_CAST(x) (bool)(x)
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#ifndef BOOST_NO_CXX11_STATIC_ASSERT
|
||||
# ifndef BOOST_NO_CXX11_VARIADIC_MACROS
|
||||
# define BOOST_STATIC_ASSERT( ... ) static_assert(__VA_ARGS__, #__VA_ARGS__)
|
||||
# else
|
||||
# define BOOST_STATIC_ASSERT( B ) static_assert(B, #B)
|
||||
# endif
|
||||
#else
|
||||
|
||||
namespace boost{
|
||||
|
||||
// HP aCC cannot deal with missing names for template value parameters
|
||||
template <bool x> struct STATIC_ASSERTION_FAILURE;
|
||||
|
||||
template <> struct STATIC_ASSERTION_FAILURE<true> { enum { value = 1 }; };
|
||||
|
||||
// HP aCC cannot deal with missing names for template value parameters
|
||||
template<std::size_t x> struct static_assert_test{};
|
||||
|
||||
}
|
||||
|
||||
//
|
||||
// Implicit instantiation requires that all member declarations be
|
||||
// instantiated, but that the definitions are *not* instantiated.
|
||||
//
|
||||
// It's not particularly clear how this applies to enum's or typedefs;
|
||||
// both are described as declarations [7.1.3] and [7.2] in the standard,
|
||||
// however some compilers use "delayed evaluation" of one or more of
|
||||
// these when implicitly instantiating templates. We use typedef declarations
|
||||
// by default, but try defining BOOST_USE_ENUM_STATIC_ASSERT if the enum
|
||||
// version gets better results from your compiler...
|
||||
//
|
||||
// Implementation:
|
||||
// Both of these versions rely on sizeof(incomplete_type) generating an error
|
||||
// message containing the name of the incomplete type. We use
|
||||
// "STATIC_ASSERTION_FAILURE" as the type name here to generate
|
||||
// an eye catching error message. The result of the sizeof expression is either
|
||||
// used as an enum initialiser, or as a template argument depending which version
|
||||
// is in use...
|
||||
// Note that the argument to the assert is explicitly cast to bool using old-
|
||||
// style casts: too many compilers currently have problems with static_cast
|
||||
// when used inside integral constant expressions.
|
||||
//
|
||||
#if !defined(BOOST_BUGGY_INTEGRAL_CONSTANT_EXPRESSIONS)
|
||||
|
||||
#if defined(BOOST_MSVC) && defined(BOOST_NO_CXX11_VARIADIC_MACROS)
|
||||
#define BOOST_STATIC_ASSERT( B ) \
|
||||
typedef ::boost::static_assert_test<\
|
||||
sizeof(::boost::STATIC_ASSERTION_FAILURE< BOOST_STATIC_ASSERT_BOOL_CAST ( B ) >)>\
|
||||
BOOST_JOIN(boost_static_assert_typedef_, __COUNTER__)
|
||||
#elif defined(BOOST_MSVC)
|
||||
#define BOOST_STATIC_ASSERT(...) \
|
||||
typedef ::boost::static_assert_test<\
|
||||
sizeof(::boost::STATIC_ASSERTION_FAILURE< BOOST_STATIC_ASSERT_BOOL_CAST (__VA_ARGS__) >)>\
|
||||
BOOST_JOIN(boost_static_assert_typedef_, __COUNTER__)
|
||||
#elif (defined(BOOST_INTEL_CXX_VERSION) || defined(BOOST_SA_GCC_WORKAROUND)) && defined(BOOST_NO_CXX11_VARIADIC_MACROS)
|
||||
// agurt 15/sep/02: a special care is needed to force Intel C++ issue an error
|
||||
// instead of warning in case of failure
|
||||
# define BOOST_STATIC_ASSERT( B ) \
|
||||
typedef char BOOST_JOIN(boost_static_assert_typedef_, __LINE__) \
|
||||
[ ::boost::STATIC_ASSERTION_FAILURE< BOOST_STATIC_ASSERT_BOOL_CAST( B ) >::value ]
|
||||
#elif (defined(BOOST_INTEL_CXX_VERSION) || defined(BOOST_SA_GCC_WORKAROUND)) && !defined(BOOST_NO_CXX11_VARIADIC_MACROS)
|
||||
// agurt 15/sep/02: a special care is needed to force Intel C++ issue an error
|
||||
// instead of warning in case of failure
|
||||
# define BOOST_STATIC_ASSERT(...) \
|
||||
typedef char BOOST_JOIN(boost_static_assert_typedef_, __LINE__) \
|
||||
[ ::boost::STATIC_ASSERTION_FAILURE< BOOST_STATIC_ASSERT_BOOL_CAST( __VA_ARGS__ ) >::value ]
|
||||
#elif defined(__sgi)
|
||||
// special version for SGI MIPSpro compiler
|
||||
#define BOOST_STATIC_ASSERT( B ) \
|
||||
BOOST_STATIC_CONSTANT(bool, \
|
||||
BOOST_JOIN(boost_static_assert_test_, __LINE__) = ( B )); \
|
||||
typedef ::boost::static_assert_test<\
|
||||
sizeof(::boost::STATIC_ASSERTION_FAILURE< \
|
||||
BOOST_JOIN(boost_static_assert_test_, __LINE__) >)>\
|
||||
BOOST_JOIN(boost_static_assert_typedef_, __LINE__)
|
||||
#elif BOOST_WORKAROUND(__MWERKS__, <= 0x3003)
|
||||
// special version for CodeWarrior <= 8.x
|
||||
#define BOOST_STATIC_ASSERT( B ) \
|
||||
BOOST_STATIC_CONSTANT(int, \
|
||||
BOOST_JOIN(boost_static_assert_test_, __LINE__) = \
|
||||
sizeof(::boost::STATIC_ASSERTION_FAILURE< BOOST_STATIC_ASSERT_BOOL_CAST( B ) >) )
|
||||
#else
|
||||
// generic version
|
||||
# ifndef BOOST_NO_CXX11_VARIADIC_MACROS
|
||||
# define BOOST_STATIC_ASSERT( ... ) \
|
||||
typedef ::boost::static_assert_test<\
|
||||
sizeof(::boost::STATIC_ASSERTION_FAILURE< BOOST_STATIC_ASSERT_BOOL_CAST( __VA_ARGS__ ) >)>\
|
||||
BOOST_JOIN(boost_static_assert_typedef_, __LINE__) BOOST_ATTRIBUTE_UNUSED
|
||||
# else
|
||||
# define BOOST_STATIC_ASSERT( B ) \
|
||||
typedef ::boost::static_assert_test<\
|
||||
sizeof(::boost::STATIC_ASSERTION_FAILURE< BOOST_STATIC_ASSERT_BOOL_CAST( B ) >)>\
|
||||
BOOST_JOIN(boost_static_assert_typedef_, __LINE__) BOOST_ATTRIBUTE_UNUSED
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#else
|
||||
// alternative enum based implementation:
|
||||
# ifndef BOOST_NO_CXX11_VARIADIC_MACROS
|
||||
# define BOOST_STATIC_ASSERT( ... ) \
|
||||
enum { BOOST_JOIN(boost_static_assert_enum_, __LINE__) \
|
||||
= sizeof(::boost::STATIC_ASSERTION_FAILURE< (bool)( __VA_ARGS__ ) >) }
|
||||
# else
|
||||
# define BOOST_STATIC_ASSERT(B) \
|
||||
enum { BOOST_JOIN(boost_static_assert_enum_, __LINE__) \
|
||||
= sizeof(::boost::STATIC_ASSERTION_FAILURE< (bool)( B ) >) }
|
||||
# endif
|
||||
#endif
|
||||
#endif // defined(BOOST_NO_CXX11_STATIC_ASSERT)
|
||||
|
||||
#endif // BOOST_STATIC_ASSERT_HPP
|
||||
|
||||
|
||||
@@ -1,14 +1,11 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
|
||||
<html>
|
||||
<head>
|
||||
<meta http-equiv="refresh" content="0; URL=../../doc/html/boost_staticassert.html">
|
||||
<meta http-equiv="refresh" content="0; URL=../config/index.html">
|
||||
</head>
|
||||
<body>
|
||||
Automatic redirection failed, please go to
|
||||
<a href="../../doc/html/boost_staticassert.html">../../doc/html/boost_staticassert.html</a>
|
||||
or view the online version at
|
||||
<a href="http://www.boost.org/regression-logs/cs-win32_metacomm/doc/html/boost_staticassert.html">
|
||||
http://www.boost.org/regression-logs/cs-win32_metacomm/doc/html/boost_staticassert.html</a>
|
||||
<a href="../config/index.html">../config/index.html</a>.
|
||||
<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>
|
||||
|
||||
@@ -4,7 +4,7 @@
|
||||
"authors": [
|
||||
"John Maddock"
|
||||
],
|
||||
"description": "Static assertions (compile time assertions).",
|
||||
"description": "Static assertions (compile time assertions). Merged into Boost.Config.",
|
||||
"category": [
|
||||
"Correctness",
|
||||
"Generic",
|
||||
|
||||
@@ -1,14 +1,11 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
|
||||
<html>
|
||||
<head>
|
||||
<meta http-equiv="refresh" content="0; URL=../../doc/html/boost_staticassert.html">
|
||||
<meta http-equiv="refresh" content="0; URL=../config/index.html">
|
||||
</head>
|
||||
<body>
|
||||
Automatic redirection failed, please go to
|
||||
<a href="../../doc/html/boost_staticassert.html">../../doc/html/boost_staticassert.html</a>
|
||||
or view the online version at
|
||||
<a href="http://www.boost.org/regression-logs/cs-win32_metacomm/doc/html/boost_staticassert.html">
|
||||
http://www.boost.org/regression-logs/cs-win32_metacomm/doc/html/boost_staticassert.html</a>
|
||||
<a href="../config/index.html">../config/index.html</a>.
|
||||
<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>
|
||||
|
||||
Reference in New Issue
Block a user