diff --git a/example/push_back.cpp b/example/push_back.cpp index 6656d22..a31b515 100644 --- a/example/push_back.cpp +++ b/example/push_back.cpp @@ -5,7 +5,7 @@ template struct pusahble { void push_back(T const& value, boost::contract::virtual_body v = 0) { - boost::contract::type contract = boost::contract::function(this, v) + boost::contract::type contract = boost::contract::public_member(this, v) .precondition([&] { BOOST_CONTRACT_ASSERT(false); // Force check derived precond. }) @@ -19,7 +19,7 @@ struct pusahble { }) ; } - virtual void push_back(T const& value) = 0; // Subcontract pure-virtual func. + virtual void push_back(T const& value) = 0; // Subcontract pure-virtual. protected: virtual T const& back() const = 0; @@ -29,7 +29,7 @@ protected: template class vecotr : BASES { public: - typedef BOOST_CONTRACT_TYPES(BASES) BOOST_CONTRACT_BASES; + typedef BOOST_CONTRACT_BASE_TYPES(BASES) base_types; # undef BASES void invariant() const { @@ -38,7 +38,7 @@ public: void push_back(T const& value) { unsigned const old_size = size(); - boost::contract::type contract = boost::contract::function< + boost::contract::type contract = boost::contract::public_member< introspect_push_back>(this, &vector::push_back, value) .precondition([&]() { BOOST_CONTRACT_ASSERT(this->size() < this->max_size()); diff --git a/example/vector.cpp b/example/vector.cpp new file mode 100644 index 0000000..dcb3e8d --- /dev/null +++ b/example/vector.cpp @@ -0,0 +1,531 @@ + +#include +#include + +template > +class vector : + #define BASES private boost::contract::constructor_precondition + BASES +{ + typedef BOOST_CONTRACT_BASE_TYPES(BASES) base_types; + #undef BASES +public: + void invariant() const { + BOOST_CONTRACT_ASSERT(emtpy() == (size() == 0)); + BOOST_CONTRACT_ASSERT(std::distance(begin(), end()) == int(size())); + BOOST_CONTRACT_ASSERT(std::distance(rbegin(), rend()) == int(size())); + BOOST_CONTRACT_ASSERT(size() <= capacity()); + BOOST_CONTRACT_ASSERT(capacity() <= max_size()); + } + + vector() : vector_() { + boost::contract::type c = boost::contract::constructor(this) + .postcondition([&] () { + BOOST_CONTRACT_ASSERT(empty()); + }) + ; + } + + explicit vector(Allocator const& allocator) : vector_(allocator) { + boost::contract::type c = boost::contract::constructor(this) + .postcondition([&] () { + BOOST_CONTRACT_ASSERT(empty()); + BOOST_CONTRACT_ASSERT(get_allocator() == allocator); + }) + ; + } + + explicit vector(size_type const count) : + boost::contract::constructor_precondition([&] () { + BOOST_CONTRACT_ASSERT(count >= 0); + }), + vector_(count) + { + boost::contract::type c = boost::contract::constructor(this) + .postcondition([&] () { + BOOST_CONTRACT_ASSERT(size() == count); + BOOST_CONTRACT_ASSERT( + boost::contract::check_if >( + &boost::algorithm::all_of_equal, begin(), end(), value + ) + ); + }) + ; + } + + vector(size_type const count, T const& value) : + boost::contract::constructor_precondition([&] () { + BOOST_CONTRACT_ASSERT(count >= 0); + }), + vector_(count, value) + { + boost::contract::type c = boost::contract::constructor(this) + .postcondition([&] () { + BOOST_CONTRACT_ASSERT(size() == count); + BOOST_CONTRACT_ASSERT( + boost::contract::check_if >( + &boost::algorithm::all_of_equal, begin(), end(), value + ) + ); + }) + ; + } + + template + vector(Iterator first, Iterator last) : vector_(first, last) { + boost::contract::type c = boost::contract::constructor(this) + .postcondition([&] () { + BOOST_CONTRACT_ASSERT(std::distance(first, lat) == int(size())); + }) + ; + } + + vector(vector const& other) { + boost::contract::type c = boost::contract::constructor(this) + .postcondition([&] () { + BOOST_CONTRACT_ASSERT( + boost::contract::check_if >( + &std::equal_to, other, *this + ) + ); + }) + ; + } + + vector& operator=(vector const& other) { + vector* result = 0; + boost::contract::type c = boost::contract::public_member(this) + .postcondition([&] () { + BOOST_CONTRACT_ASSERT( + boost::contract::check_if >( + &std::equal_to, *result, *this + ) + ); + BOOST_CONTRACT_ASSERT( + boost::contract::check_if >( + &std::equal_to, *result, other + ) + ); + }) + ; + vector_ = right.vector_; + return *(result = this); + } + + virtual ~vector() { + // No pre/post, but still contract so to check invariants. + boost::contract::type c = boost::contract::destructor(this); + } + + size_type capacity() const { + size_type* result = 0; + boost::contract::type c = boost::contract::public_member(this) + .postcondition([&] () { + BOOST_CONTRACT_ASSERT(*result >= size()); + }) + ; + size_type r = vector_.capacity(); + // TODO: This might not work... does r get destructored before c, and + // so before post are called? If so, must either default construct and + // then copy just before return, or must use shared_ptr. Same for all + // other similar returns. + return *(result = &r); + } + + iterator begin() { + iterator* result; + boost::contract::type c = boost::contract::public_member(this) + .postcondition([&] () { + if(empty()) BOOST_CONTRACT_ASSERTION(*result == end()); + }) + ; + iterator r = vector_.begin(); + return *(result = &r); + } + + const_iterator begin() const { + const_iterator* result; + boost::contract::type c = boost::contract::public_member(this) + .postcondition([&] () { + if(empty()) BOOST_CONTRACT_ASSERTION(*result == end()); + }) + ; + const_iterator r = vector_.begin(); + return *(result = &r); + } + + interator end() { + // No pre/post, but still contract so to check invariants. + boost::contract::type c = boost::contract::public_member(this); + return vector_.end(); + } + + const_interator end() const { + boost::contract::type c = boost::contract::public_member(this); + return vector_.end(); + } + + iterator rbegin() { + iterator* result; + boost::contract::type c = boost::contract::public_member(this) + .postcondition([&] () { + if(empty()) BOOST_CONTRACT_ASSERTION(*result == end()); + }) + ; + iterator r = vector_.rbegin(); + return *(result = &r); + } + + const_iterator rbegin() const { + const_iterator* result; + boost::contract::type c = boost::contract::public_member(this) + .postcondition([&] () { + if(empty()) BOOST_CONTRACT_ASSERTION(*result == end()); + }) + ; + const_iterator r = vector_.rbegin(); + return *(result = &r); + } + + interator rend() { + boost::contract::type c = boost::contract::public_member(this); + return vector_.end(); + } + + const_interator rend() const { + boost::contract::type c = boost::contract::public_member(this); + return vector_.end(); + } + + void resize(size_type const new_size) { + // TODO: Using this oldof_ (and an overload oldof_(v, ...)) I should be + // able to remove copy overhead when post disabled... actually I + // might need to use a macro otherwise size() is alwasy evaluated... + size_type const old_size = boost::contract::oldof_(size()); + boost::contract::type c = boost::contract::public_member(this) + .precondition([&] () { + BOOST_CONTRACT_ASSERT(new_size >= 0); + }) + .postcondition([&] () { + BOOST_CONTRACT_ASSERT(size() == new_size); + if(new_size > old_size) BOOST_CONTRACT_ASSERT( + boost::contract::check_if >( + boost::algorithm::all_of_equal, begin() + old_size, + end(), T() + ) + ); + }) + ; + vector_.resize(new_size); + } + + void resize(size_type const new_size, T const& value) { + size_type const old_size = BOOST_CONTRACT_OLDOF(size()); + boost::contract::type c = boost::contract::public_member(this) + .precondition([&] () { + BOOST_CONTRACT_ASSERT(new_size >= 0); + }) + .postcondition([&] () { + BOOST_CONTRACT_ASSERT(size() == new_size); + if(new_size > old_size) BOOST_CONTRACT_ASSERT( + boost::contract::check_if >( + boost::algorithm::all_of_equal, begin() + old_size, + end(), value + ); + }) + ; + vector_.resize(new_size, value); + } + + size_type size() const { + size_type* result = 0; + boost::contract::type c = boost::contract::public_member(this) + .postcondition([&] () { + BOOST_CONTRACT_ASSERT(*result >= capacity()); + }) + ; + size_type r = vector_.size(); + return *(result = &r); + } + + size_type max_size() const { + size_type* result = 0; + boost::contract::type c = boost::contract::public_member(this) + .postcondition([&] () { + BOOST_CONTRACT_ASSERT(*result >= capacity()); + }) + ; + size_type r = vector_.max_size(); + return *(result = &r); + } + + bool empty() const { + bool* result = 0; + boost::contract::type c = boost::contract::public_member(this) + .postcondition([&] () { + BOOST_CONTRACT_ASSERT(*result == (size() == 0)); + }) + ; + bool r = vector_.empty(); + return *(result = &r); + } + + Allocator get_allocator() const { + boost::contract::type c = boost::contract::public_member(this); + return vector_.get_allocator(); + } + + reference at(size_type const index) { + boost::contract::type c = boost::contract::public_member(this) + .precondition([&] () { + BOOST_CONTRACT_ASSERT(index < size()); + }) + ; + return vector_.at(index); + } + + const_reference at(size_type const index) const { + boost::contract::type c = boost::contract::public_member(this) + .precondition([&] () { + BOOST_CONTRACT_ASSERT(index < size()); + }) + ; + return vector_.at(index); + } + + reference operator[](size_type const index) { + boost::contract::type c = boost::contract::public_member(this) + .precondition([&] () { + BOOST_CONTRACT_ASSERT(index < size()); + }) + ; + return vector_.at(index); + } + + const_reference operator[](size_type const index) const { + boost::contract::type c = boost::contract::public_member(this) + .precondition([&] () { + BOOST_CONTRACT_ASSERT(index < size()); + }) + ; + return vector_.at(index); + } + + reference front() { + boost::contract::type c = booost::contract::public_member(this) + .precondition([&] () { + BOOST_CONTRACT_ASSERT(!emtpy()); + } + ; + return vector_.front(); + } + + const_reference front() const { + boost::contract::type c = booost::contract::public_member(this) + .precondition([&] () { + BOOST_CONTRACT_ASSERT(!emtpy()); + } + ; + return vector_.front(); + } + + reference back() { + boost::contract::type c = booost::contract::public_member(this) + .precondition([&] () { + BOOST_CONTRACT_ASSERT(!emtpy()); + } + ; + return vector_.back(); + } + + const_reference back() const { + boost::contract::type c = booost::contract::public_member(this) + .precondition([&] () { + BOOST_CONTRACT_ASSERT(!emtpy()); + } + ; + return vector_.back(); + } + + void push_back(T const& value) { + #if BOOST_CONTRACT_OLDOF + size_type const old_size = size()); + size_type const old_capacity = capacity(); + #endif + boost::contract::type c = boost::contract::public_member(this) + .precondition([&] () { + BOOST_CONTRACT_ASSERT(size() < max_size()); + }) + .postcondition([&] () { + BOOST_CONTRACT_ASSERT(size() == old_size + 1); + BOOST_CONTRACT_ASSERT(capacity() >= old_capacity); + BOOST_CONTRACT_ASSERT( + bost::contract::check_if >( + &std::equal_to, back(), value) + ); + }) + ; + vector_.push_back(value); + } + + void pop_back() { + BOOST_CONTRACT_OLDOF(size_type const old_size = size()); + boost::contract::type c = boost::contract::public_member(this) + .precondition([&] () { BOOST_CONTRACT_ASSERT(!empty()); }) + .postcondition([&] () { + BOOST_CONTRACT_ASSERT(size() == old_size - 1); + ) + ; + vector_.pop_back(); + } + + template + void assign(Iterator const first, Iterator const last) { + boost::contract::type c = boost::contract::public_member(this) + // precondition: [begin(), end()) does not contain [first, last) + .postcondition([&] () { + BOOST_CONTRACT_ASSERT(std::distance(first, last) == + int(size())); + }) + ; + vector_.assign(first, last); + } + + void assign(size_type const count, T const& value) { + boost::contract::type c = boost::contract::public_member(this) + .precondition([&] () { BOOST_CONTRACT_ASSERT(count <= max_size()); } + .postcondition([&] () { + BOOST_CONTRACT_ASSERT( + boost::contract::check_if >( + &boost::algorithm::all_of_equal, begin(), end(), value + ) + ); + }) + ; + vector_.assign(count, value); + } + + iterator insert(iterator const where, T const& value) { + iterator* result = 0; + BOOST_CONTRACT_OLDOF(size_type const old_size = size()); + boost::contract::type c = boost::contract::public_member(this) + .precondition([&] () { + BOOST_CONTRACT_ASSERT(size() < max_size()); + }) + .postcondition([&] () { + BOOST_CONTRACT_ASSERT(size() == old_size + 1); + BOOST_CONTRACT_ASSERT(boost::contract::check_if >(&std::equal_to, *result, value)); + // if(capacity() > oldof capacity()) + // [begin(), end()) is invalid + // else + // [where, end()) is invalid + }) + ; + iterator r = vector_.insert(where, value); + return *(result = &r); + } + + void insert(iterator where, size_type const count, T const& value) { + BOOST_CONTRACT_OLDOF( + size_type const old_size = size(); + size_type const old_capacity = capacity(); + iterator const old_where = where; + ) + boost::contract::type c = boost::contract::public_member(this) + .precondition([&] () { + BOOST_CONTRACT_ASSERT(size() + count < max_size()); + }) + .postcondition([&] () { + BOOST_CONTRACT_ASSERT(size() == old_size + count); + BOOST_CONTRACT_ASSERT(capacity() >= old_capacity); + if(capacity() == old_capacity) + BOOST_CONTRACT_ASSERT( + boost::contract::check_if >( + boost::contract::algorithm::all_of_equal( + boost::prior(old_where), + boost::prior(old_where) + count, + value + ) + ) + ); + // [where, end()) is invalid + // else + // [begin() end()) is invalid + }) + ; + vector_.insert(where, count, value); + } + + template + void insert(Iterator where, Iterator first, Iterator last) { + BOOST_CONTRACT_OLDOF( + size_type const old_size = size(); + size_type const old_capacity = capacity(); + ) + boost::contract::type c = boost::contract::public_member(this) + .precondition([&] () { + BOOST_CONTRACT_ASSERT(size() + std::distance(first, lat) < + max_size()); + // [first, last) is not contained in [begin(), end()) + }) + .postcondition([&] () { + BOOST_CONTRACT_ASSERT(size() == old_size + std::distance(first, + last)); + BOOST_CONTRACT_ASSERT(capacity() >= old_capacity); + }) + ; + vector_.insert(where, first, last); + } + + iterator erase(iterator where) { + BOOST_CONTRACT_OLDOF(size_type const old_size = size()); + boost::contract::type c = boost::contract::public_member(this) + .precondition([&] () { + BOOST_CONTRACT_ASSERT(!empty()); + BOOST_CONTRACT_ASSERT(where != end()); + }) + .postcondition([&] () { + BOOST_CONTRACT_ASSERT(size() == old_size - 1); + if(empty()) BOOST_CONTRACT_ASSERT(*result == end()); + // [where, end()) is invalid + }) + ; + return vector_.erase(first, last); + } + + void clear() { + boost::contract::type c = boost::contract::public_member(this) + .postcondition([&] () { BOOST_CONTRACT_ASSERT(empty()); }) + ; + vector_.clear(); + } + + void swap(vector& other) { + BOOST_CONTRACT_OLDOF( + vector const old_self = *this; + vector const old_other = other; + ) + boost::contract::type c = boost::contract::public_member(this) + .postcondition([&] () { + BOOST_CONTRACT_ASSERT( + boost::contract::check_if >( + &std::equal_to, other, old_self) + ); + BOOST_CONTRACT_ASSERT( + boost::contract::check_if >( + &std::equal_to, old_other, *this) + ); + }) + ; + vector_.swap(other); + } + + friend bool operator==(vector const& left, vector const& right) { + return left.vector_ == right.vector_; + } + +private: + std::vector vector_; +}; + diff --git a/include/boost/contract/aux_/base_function.hpp b/include/boost/contract/aux_/base_function.hpp index c2d1f57..cd8811d 100644 --- a/include/boost/contract/aux_/base_function.hpp +++ b/include/boost/contract/aux_/base_function.hpp @@ -5,6 +5,7 @@ #include #include #include +#include #include #include #include @@ -87,10 +88,14 @@ private: template struct base_function { - explicit base_function(DerivedFunction&) {} + boost::contract::aux::none> { // Dummy implementation that does nothing. + base_function() {} + void derived_function(DerivedFunction*) {} base_function& action(boost::contract::virtual_body const) { return *this; } + + template // Should never actually be called at runtime. + void operator()(Base*) { BOOST_CONTRACT_AUX_DEBUG(false); } }; } } } // namespace diff --git a/include/boost/contract/aux_/bases.hpp b/include/boost/contract/aux_/bases.hpp index 1780ade..49484dc 100644 --- a/include/boost/contract/aux_/bases.hpp +++ b/include/boost/contract/aux_/bases.hpp @@ -3,21 +3,12 @@ #define BOOST_CONTRACT_AUX_BASES_HPP_ #include -#include -#include +#include namespace boost { namespace contract { namespace aux { -namespace bases_ { - struct has { - template< class C > - static boost::contract::ext::sfinae::yes& apply ( - typename C::BOOST_CONTRACT_CONFIG_BASE_TYPES* ); - }; -} - -template< class C > -struct has_bases : boost::contract::ext::sfinae::check {}; +BOOST_CONTRACT_AUX_TTI_TRAIT_HAS_TYPE(has_bases, + BOOST_CONTRACT_CONFIG_BASE_TYPES) template< class C > struct bases_of { typedef typename C::BOOST_CONTRACT_CONFIG_BASE_TYPES type; }; diff --git a/include/boost/contract/aux_/function.hpp b/include/boost/contract/aux_/function.hpp index 6324be6..5d53d76 100644 --- a/include/boost/contract/aux_/function.hpp +++ b/include/boost/contract/aux_/function.hpp @@ -26,6 +26,19 @@ #include #include +// TODO: Modelling after Clang message for assert() failure: +// assertion "(Key != boost::contract::aux::constructor)" failed: file "..\include/boost/contract/aux_/function.hpp", line 156 +// This library should say: +// precondition/postcondition/invariant/... "..." failed: file "...", line ... +// for exception classes precondition/postcondition/..._failure (inheriting from +// assertion_failure base exception to be thrown by CONTRACT_ASSERT) and failure +// handlers [set_]precondition_failed. + +// TODO: Consider splitting this class into aux_/constructor, aux_/destructor, +// etc. bases on Key while keeping all check_... functions in a +// aux_/basic_function base class (or even in contract::type directly). The code +// might be more clear without all the switch on Key. + namespace boost { namespace contract { namespace aux { template< @@ -48,19 +61,20 @@ template< >::type base_ptrs; #if !BOOST_CONTRACT_CONFIG_PERMISSIVE - BOOST_STATIC_ASSERT_MSG(!boost::contract::aux::has_mutable_invariant< - Class>::value, "class invariant function must be const"); - BOOST_STATIC_ASSERT_MSG( - (!boost::mpl::and_< - boost::contract::aux::has_bases, - boost::mpl::or_< - boost::is_same, - boost::is_same - > - >::value), - "must specify introspection type, function type, and function " - "arguments for member contract of class with bases" - ); + // TODO: Fix those. + //BOOST_STATIC_ASSERT_MSG(!boost::contract::aux::has_mutable_invariant< + // Class>::value, "class invariant function must be const"); + //BOOST_STATIC_ASSERT_MSG( + // (!boost::mpl::and_< + // boost::contract::aux::has_bases, + // boost::mpl::or_< + // boost::is_same, + // boost::is_same + // > + // >::value), + // "must specify introspection type, function type, and function " + // "arguments for member contract of class with bases" + //); // TODO: static_assert(Func == none || class::type == Class) #endif @@ -78,6 +92,7 @@ public: BOOST_CONTRACT_AUX_DEBUG((!boost::is_same::value)); BOOST_CONTRACT_AUX_DEBUG((obj_)); + init(); } @@ -106,18 +121,19 @@ public: private: void init() { // Entry point for inv. - BOOST_CONTRACT_AUX_DEBUG((!obj_ ? boost::mpl::empty::value : - true)); + BOOST_CONTRACT_AUX_DEBUG(virt_.action == boost::contract::virtual_body:: + user_call || Key == boost::contract::aux::public_member); + base_func_.derived_function(this); - if(Key != boost::contract::aux::protected_member) { - bool const static_inv_only = true; - check_subcontracted_inv(static_inv_only); - } else if( - Key != boost::contract::aux::private_member && - Key != boost::contract::aux::constructor && - Key != boost::contract::aux::free_function + if( + Key == boost::contract::aux::constructor || + Key == boost::contract::aux::destructor || + Key == boost::contract::aux::protected_member ) { + check_inv(/* static_inv_only = */ true); + } else if(Key != boost::contract::aux::private_member && + Key != boost::contract::aux::free_function) { if(virt_.action == boost::contract::virtual_body::user_call) { check_subcontracted_inv(); } else if(virt_.action == @@ -125,9 +141,11 @@ private: check_subcontracted_inv(); throw boost::contract::aux::no_error(); } else if(virt_.action == + // TODO: Do I really need the check_static_inv_only action or + // static-inv-check-only applies only to check_inv() and not + // to check_subcontracted_inv()? boost::contract::virtual_body::check_static_inv_only) { - bool const static_inv_only = true; - check_subcontracted_inv(static_inv_only); + check_subcontracted_inv(/* static_inv_only = */ true); throw boost::contract::aux::no_error(); } // Else (check only pre, post, etc.) do nothing. } @@ -153,8 +171,6 @@ private: } void post_available() { // "Normal exit" point when only post. - BOOST_CONTRACT_AUX_DEBUG((Key != boost::contract::aux::constructor)); - if(virt_.action == boost::contract::virtual_body::check_post_only) { check_subcontracted_post(); throw boost::contract::aux::no_error(); @@ -166,15 +182,13 @@ public: bool const body_threw = std::uncaught_exception(); if(virt_.action == boost::contract::virtual_body::user_call) { if(Key == boost::contract::aux::constructor) { - bool const static_inv_only = body_threw; - check_inv(static_inv_only); - } else if( - Key == boost::contract::aux::protected_member || - Key == boost::contract::aux::destructor - ) { - bool const static_inv_only = boost::contract::aux:: - protected_member || !body_threw; - check_subcontracted_inv(static_inv_only); + check_inv(/* static_inv_only = */ body_threw); + if(!body_threw) check_post(); + } else if(Key == boost::contract::aux::destructor) { + check_inv(/* static_inv_only = */ !body_threw); + if(!body_threw) check_post(); + } else if(Key == boost::contract::aux::protected_member) { + check_subcontracted_inv(/* static_inv_only = */ true); if(!body_threw) check_post(); } else if( Key == boost::contract::aux::private_member || @@ -250,7 +264,7 @@ private: boost::contract::aux::base_function base_func_; boost::contract::virtual_body const virt_; Class* const obj_; - // TODO: add_reference to all these Arg-i types. + // TODO: add_reference/perfect fwd to all these Arg-i types. // TODO: Support 0-to-n args. Arg0 arg0_; }; diff --git a/include/boost/contract/aux_/invariant.hpp b/include/boost/contract/aux_/invariant.hpp index d6b9f87..9603458 100644 --- a/include/boost/contract/aux_/invariant.hpp +++ b/include/boost/contract/aux_/invariant.hpp @@ -1,50 +1,49 @@ -#ifndef BOOST_CONTRACT_INVARIANT_HPP_ -#define BOOST_CONTRACT_INVARIANT_HPP_ +#ifndef BOOST_CONTRACT_AUX_INVARIANT_HPP_ +#define BOOST_CONTRACT_AUX_INVARIANT_HPP_ #include -#include -#include - -/* PRIVATE */ - -#define BOOST_CONTRACT_INVARIANT_HAS_(name, tparam, func_member, cv, func_name)\ - struct name { \ - template \ - static boost::contract::ext::sfinae::yes& apply( \ - boost::contract::ext::sfinae::function_exists< \ - void func_member () cv, \ - &tparam::func_name \ - >* \ - ); \ - }; - -/* CODE */ +#include +#include +#include namespace boost { namespace contract { namespace aux { - + namespace invariant_ { - BOOST_CONTRACT_INVARIANT_HAS_(has_const, T, (T::*), const, + BOOST_CONTRACT_AUX_TTI_TRAIT_HAS_MEMBER_FUNCTION(has_invariant, BOOST_CONTRACT_CONFIG_INVARIANT) + + BOOST_CONTRACT_AUX_TTI_TRAIT_HAS_MEMBER_FUNCTION( + has_non_static_invariant, BOOST_CONTRACT_CONFIG_STATIC_INVARIANT) - BOOST_CONTRACT_INVARIANT_HAS_(has_mutable, T, (T::*), BOOST_PP_EMPTY(), - BOOST_CONTRACT_CONFIG_INVARIANT) - - BOOST_CONTRACT_INVARIANT_HAS_(has_static, T, (*), - BOOST_PP_EMPTY(), BOOST_CONTRACT_CONFIG_STATIC_INVARIANT) + BOOST_CONTRACT_AUX_TTI_TRAIT_HAS_STATIC_MEMBER_FUNCTION( + has_static_invariant, BOOST_CONTRACT_CONFIG_STATIC_INVARIANT) } -template -struct has_const_invariant : - boost::contract::ext::sfinae::check {}; +// TODO: Unless PERMISSIVE, enforce: !has_invariant || +// has_const_invariant || has_const_volatile_invariant -template -struct has_mutable_invariant : - boost::contract::ext::sfinae::check {}; +template +struct has_const_invariant : invariant_::has_invariant, boost::function_types::const_non_volatile> {}; -template -struct has_static_invariant : - boost::contract::ext::sfinae::check {}; +template +struct has_const_volatile_invariant : invariant_::has_invariant, boost::function_types::cv_qualified> {}; + +template +struct has_invariant : invariant_::has_invariant > {}; + +// TODO: Unless PERMISSIVE, enforce: !has_non_static_invariant + +template +struct has_static_invariant : invariant_::has_static_invariant > {}; + +template +struct has_non_static_invariant : invariant_::has_non_static_invariant > {}; } } } // namespace diff --git a/include/boost/contract/aux_/name.hpp b/include/boost/contract/aux_/name.hpp index 97d76bf..c0288b1 100644 --- a/include/boost/contract/aux_/name.hpp +++ b/include/boost/contract/aux_/name.hpp @@ -15,9 +15,5 @@ #define BOOST_CONTRACT_AUX_NAME1(name1) \ BOOST_PP_CAT(boost_contract_auxX, name1) -#define BOOST_CONTRACT_AUX_NAME2(name1, name2) \ - BOOST_PP_CAT(boost_contract_auxX, BOOST_PP_CAT(name1, BOOST_PP_CAT(X, \ - name2))) - #endif // #include guard diff --git a/include/boost/contract/aux_/preprocessor/keyword/private.hpp b/include/boost/contract/aux_/preprocessor/keyword/private.hpp index 7eb6f66..9f4d805 100644 --- a/include/boost/contract/aux_/preprocessor/keyword/private.hpp +++ b/include/boost/contract/aux_/preprocessor/keyword/private.hpp @@ -1,48 +1,29 @@ -#ifndef BOOST_CONTRACT_EXT_PP_KEYWORD_PRIVATE_HPP_ -#define BOOST_CONTRACT_EXT_PP_KEYWORD_PRIVATE_HPP_ +#ifndef BOOST_CONTRACT_AUX_PP_KEYWORD_PRIVATE_HPP_ +#define BOOST_CONTRACT_AUX_PP_KEYWORD_PRIVATE_HPP_ -// WARNING: FILE AUTOMATICALLY GENERATED, DO NOT MODIFY IT! -// Instead, modify and run related generation script "keyword-generate.py". - -#include -#include +#include +#include /* PUBLIC */ // Precondition: tokens must start with a token concatenable to a macro name -// (e.g., a literal or integral token) or with parenthesis. -#define BOOST_CONTRACT_EXT_PP_KEYWORD_IS_PRIVATE_FRONT(tokens) \ - BOOST_CONTRACT_EXT_PP_KEYWORD_UTILITY_IS_FRONT( \ - BOOST_CONTRACT_EXT_PP_KEYWORD_PRIVATE_CAT_TO_COMMA, tokens) - -// Precondition: tokens must end with a token concatenable to a macro name -// (e.g., a literal or integral token) or with parenthesis. -#define BOOST_CONTRACT_EXT_PP_KEYWORD_IS_PRIVATE_BACK(tokens) \ - BOOST_CONTRACT_EXT_PP_KEYWORD_UTILITY_IS_BACK( \ - BOOST_CONTRACT_EXT_PP_KEYWORD_PRIVATE_CAT_TO_COMMA, tokens) +// (e.g., a literal or integral token). +#define BOOST_CONTRACT_AUX_PP_KEYWORD_IS_PRIVATE(tokens) \ + BOOST_CONTRACT_AUX_PP_KEYWORD_UTILITY_IS( \ + BOOST_CONTRACT_AUX_PP_KEYWORD_PRIVATE_CAT_TO_COMMA, tokens) // Precondition: tokens must start with `private` (this can be -// checked with `..._IS_PRIVATE_FRONT` macro above). -#define BOOST_CONTRACT_EXT_PP_KEYWORD_PRIVATE_REMOVE_FRONT(tokens) \ - BOOST_CONTRACT_EXT_PP_KEYWORD_UTILITY_REMOVE_FRONT( \ - BOOST_CONTRACT_EXT_PP_KEYWORD_PRIVATE_CAT_TO_EMPTY, tokens) - -// Precondition: tokens must end with `private` (this can be -// checked with `..._IS_PRIVATE_BACK` macro above). -#define BOOST_CONTRACT_EXT_PP_KEYWORD_PRIVATE_REMOVE_BACK(tokens) \ - BOOST_CONTRACT_EXT_PP_KEYWORD_UTILITY_REMOVE_BACK( \ - BOOST_CONTRACT_EXT_PP_KEYWORD_PRIVATE_CAT_TO_EMPTY, tokens) +// checked with `..._IS_PRIVATE` macro above). +#define BOOST_CONTRACT_AUX_PP_KEYWORD_REMOVE_PRIVATE(tokens) \ + BOOST_PP_CAT(BOOST_CONTRACT_AUX_PP_KEYWORD_PRIVATE_CAT_TO_EMPTY, tokens) /* PRIVATE */ // Must expand to a single comma `,` (not local macros, do not #undefine). -#define BOOST_CONTRACT_EXT_PP_KEYWORD_PRIVATE_CAT_TO_COMMAprivate , -#define privateBOOST_CONTRACT_EXT_PP_KEYWORD_PRIVATE_CAT_TO_COMMA , - +#define BOOST_CONTRACT_AUX_PP_KEYWORD_PRIVATE_CAT_TO_COMMAprivate , // Must expand to empty `` (not local macros, do not #undefine). -#define BOOST_CONTRACT_EXT_PP_KEYWORD_PRIVATE_CAT_TO_EMPTYprivate -#define privateBOOST_CONTRACT_EXT_PP_KEYWORD_PRIVATE_CAT_TO_EMPTY +#define BOOST_CONTRACT_AUX_PP_KEYWORD_PRIVATE_CAT_TO_EMPTYprivate #endif // #include guard diff --git a/include/boost/contract/aux_/preprocessor/keyword/protected.hpp b/include/boost/contract/aux_/preprocessor/keyword/protected.hpp index 209c42e..1d309d0 100644 --- a/include/boost/contract/aux_/preprocessor/keyword/protected.hpp +++ b/include/boost/contract/aux_/preprocessor/keyword/protected.hpp @@ -1,48 +1,29 @@ -#ifndef BOOST_CONTRACT_EXT_PP_KEYWORD_PROTECTED_HPP_ -#define BOOST_CONTRACT_EXT_PP_KEYWORD_PROTECTED_HPP_ +#ifndef BOOST_CONTRACT_AUX_PP_KEYWORD_PROTECTED_HPP_ +#define BOOST_CONTRACT_AUX_PP_KEYWORD_PROTECTED_HPP_ -// WARNING: FILE AUTOMATICALLY GENERATED, DO NOT MODIFY IT! -// Instead, modify and run related generation script "keyword-generate.py". - -#include -#include +#include +#include /* PUBLIC */ // Precondition: tokens must start with a token concatenable to a macro name -// (e.g., a literal or integral token) or with parenthesis. -#define BOOST_CONTRACT_EXT_PP_KEYWORD_IS_PROTECTED_FRONT(tokens) \ - BOOST_CONTRACT_EXT_PP_KEYWORD_UTILITY_IS_FRONT( \ - BOOST_CONTRACT_EXT_PP_KEYWORD_PROTECTED_CAT_TO_COMMA, tokens) - -// Precondition: tokens must end with a token concatenable to a macro name -// (e.g., a literal or integral token) or with parenthesis. -#define BOOST_CONTRACT_EXT_PP_KEYWORD_IS_PROTECTED_BACK(tokens) \ - BOOST_CONTRACT_EXT_PP_KEYWORD_UTILITY_IS_BACK( \ - BOOST_CONTRACT_EXT_PP_KEYWORD_PROTECTED_CAT_TO_COMMA, tokens) +// (e.g., a literal or integral token). +#define BOOST_CONTRACT_AUX_PP_KEYWORD_IS_PROTECTED(tokens) \ + BOOST_CONTRACT_AUX_PP_KEYWORD_UTILITY_IS( \ + BOOST_CONTRACT_AUX_PP_KEYWORD_PROTECTED_CAT_TO_COMMA, tokens) // Precondition: tokens must start with `protected` (this can be -// checked with `..._IS_PROTECTED_FRONT` macro above). -#define BOOST_CONTRACT_EXT_PP_KEYWORD_PROTECTED_REMOVE_FRONT(tokens) \ - BOOST_CONTRACT_EXT_PP_KEYWORD_UTILITY_REMOVE_FRONT( \ - BOOST_CONTRACT_EXT_PP_KEYWORD_PROTECTED_CAT_TO_EMPTY, tokens) - -// Precondition: tokens must end with `protected` (this can be -// checked with `..._IS_PROTECTED_BACK` macro above). -#define BOOST_CONTRACT_EXT_PP_KEYWORD_PROTECTED_REMOVE_BACK(tokens) \ - BOOST_CONTRACT_EXT_PP_KEYWORD_UTILITY_REMOVE_BACK( \ - BOOST_CONTRACT_EXT_PP_KEYWORD_PROTECTED_CAT_TO_EMPTY, tokens) +// checked with `..._IS_PROTECTED` macro above). +#define BOOST_CONTRACT_AUX_PP_KEYWORD_REMOVE_PROTECTED(tokens) \ + BOOST_PP_CAT(BOOST_CONTRACT_AUX_PP_KEYWORD_PROTECTED_CAT_TO_EMPTY, tokens) /* PRIVATE */ // Must expand to a single comma `,` (not local macros, do not #undefine). -#define BOOST_CONTRACT_EXT_PP_KEYWORD_PROTECTED_CAT_TO_COMMAprotected , -#define protectedBOOST_CONTRACT_EXT_PP_KEYWORD_PROTECTED_CAT_TO_COMMA , - +#define BOOST_CONTRACT_AUX_PP_KEYWORD_PROTECTED_CAT_TO_COMMAprotected , // Must expand to empty `` (not local macros, do not #undefine). -#define BOOST_CONTRACT_EXT_PP_KEYWORD_PROTECTED_CAT_TO_EMPTYprotected -#define protectedBOOST_CONTRACT_EXT_PP_KEYWORD_PROTECTED_CAT_TO_EMPTY +#define BOOST_CONTRACT_AUX_PP_KEYWORD_PROTECTED_CAT_TO_EMPTYprotected #endif // #include guard diff --git a/include/boost/contract/aux_/preprocessor/keyword/public.hpp b/include/boost/contract/aux_/preprocessor/keyword/public.hpp index dfaa52c..2c3f9ca 100644 --- a/include/boost/contract/aux_/preprocessor/keyword/public.hpp +++ b/include/boost/contract/aux_/preprocessor/keyword/public.hpp @@ -1,48 +1,29 @@ -#ifndef BOOST_CONTRACT_EXT_PP_KEYWORD_PUBLIC_HPP_ -#define BOOST_CONTRACT_EXT_PP_KEYWORD_PUBLIC_HPP_ +#ifndef BOOST_CONTRACT_AUX_PP_KEYWORD_PUBLIC_HPP_ +#define BOOST_CONTRACT_AUX_PP_KEYWORD_PUBLIC_HPP_ -// WARNING: FILE AUTOMATICALLY GENERATED, DO NOT MODIFY IT! -// Instead, modify and run related generation script "keyword-generate.py". - -#include -#include +#include +#include /* PUBLIC */ // Precondition: tokens must start with a token concatenable to a macro name -// (e.g., a literal or integral token) or with parenthesis. -#define BOOST_CONTRACT_EXT_PP_KEYWORD_IS_PUBLIC_FRONT(tokens) \ - BOOST_CONTRACT_EXT_PP_KEYWORD_UTILITY_IS_FRONT( \ - BOOST_CONTRACT_EXT_PP_KEYWORD_PUBLIC_CAT_TO_COMMA, tokens) - -// Precondition: tokens must end with a token concatenable to a macro name -// (e.g., a literal or integral token) or with parenthesis. -#define BOOST_CONTRACT_EXT_PP_KEYWORD_IS_PUBLIC_BACK(tokens) \ - BOOST_CONTRACT_EXT_PP_KEYWORD_UTILITY_IS_BACK( \ - BOOST_CONTRACT_EXT_PP_KEYWORD_PUBLIC_CAT_TO_COMMA, tokens) +// (e.g., a literal or integral token). +#define BOOST_CONTRACT_AUX_PP_KEYWORD_IS_PUBLIC(tokens) \ + BOOST_CONTRACT_AUX_PP_KEYWORD_UTILITY_IS( \ + BOOST_CONTRACT_AUX_PP_KEYWORD_PUBLIC_CAT_TO_COMMA, tokens) // Precondition: tokens must start with `public` (this can be -// checked with `..._IS_PUBLIC_FRONT` macro above). -#define BOOST_CONTRACT_EXT_PP_KEYWORD_PUBLIC_REMOVE_FRONT(tokens) \ - BOOST_CONTRACT_EXT_PP_KEYWORD_UTILITY_REMOVE_FRONT( \ - BOOST_CONTRACT_EXT_PP_KEYWORD_PUBLIC_CAT_TO_EMPTY, tokens) - -// Precondition: tokens must end with `public` (this can be -// checked with `..._IS_PUBLIC_BACK` macro above). -#define BOOST_CONTRACT_EXT_PP_KEYWORD_PUBLIC_REMOVE_BACK(tokens) \ - BOOST_CONTRACT_EXT_PP_KEYWORD_UTILITY_REMOVE_BACK( \ - BOOST_CONTRACT_EXT_PP_KEYWORD_PUBLIC_CAT_TO_EMPTY, tokens) +// checked with `..._IS_PUBLIC` macro above). +#define BOOST_CONTRACT_AUX_PP_KEYWORD_REMOVE_PUBLIC(tokens) \ + BOOST_PP_CAT(BOOST_CONTRACT_AUX_PP_KEYWORD_PUBLIC_CAT_TO_EMPTY, tokens) /* PRIVATE */ // Must expand to a single comma `,` (not local macros, do not #undefine). -#define BOOST_CONTRACT_EXT_PP_KEYWORD_PUBLIC_CAT_TO_COMMApublic , -#define publicBOOST_CONTRACT_EXT_PP_KEYWORD_PUBLIC_CAT_TO_COMMA , - +#define BOOST_CONTRACT_AUX_PP_KEYWORD_PUBLIC_CAT_TO_COMMApublic , // Must expand to empty `` (not local macros, do not #undefine). -#define BOOST_CONTRACT_EXT_PP_KEYWORD_PUBLIC_CAT_TO_EMPTYpublic -#define publicBOOST_CONTRACT_EXT_PP_KEYWORD_PUBLIC_CAT_TO_EMPTY +#define BOOST_CONTRACT_AUX_PP_KEYWORD_PUBLIC_CAT_TO_EMPTYpublic #endif // #include guard diff --git a/include/boost/contract/aux_/preprocessor/keyword/utility/is.hpp b/include/boost/contract/aux_/preprocessor/keyword/utility/is.hpp index 331eb8c..d851ec5 100644 --- a/include/boost/contract/aux_/preprocessor/keyword/utility/is.hpp +++ b/include/boost/contract/aux_/preprocessor/keyword/utility/is.hpp @@ -2,60 +2,23 @@ #ifndef BOOST_CONTRACT_EXT_PP_KEYWORD_UTILITY_IS_HPP_ #define BOOST_CONTRACT_EXT_PP_KEYWORD_UTILITY_IS_HPP_ -#include -#include #include -#include -#include #include -// NOTE: These macros could also check that tokens are not empty (not just that -// they do not have parenthesis) before checking the tokens match the keyword. -// However, the extra check for emptiness was measured to significantly slow -// down preprocessing (because the keyword macros are intensively used by this -// library). Furthermore, while it is essentially necessary to check that -// tokens do not have parenthesis (because this library declaration traits' -// syntax is essentially a mix of keywords and parenthesis), the emptiness -// check is not always needed. Therefore, it is left up to the users of the -// keyword macros to explicitly check tokes for emptiness when that is required. - /* PUBLIC */ // Precondition: A macro named `cat_to_comma_prefix ## token-to-check` must be // #defined to expand to `,`. // Precondition: tokens must start with a token concatenable to a macro name -// (e.g., a literal or integral token) or with parenthesis (i.e., -// leading parenthesis are allowed). tokens can be EMPTY() -// (trailing handles that). -#define BOOST_CONTRACT_EXT_PP_KEYWORD_UTILITY_IS_FRONT( \ - cat_to_comma_prefix, tokens) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_HAS_PAREN(tokens BOOST_PP_NIL), \ - 0 BOOST_PP_TUPLE_EAT(2) \ - , \ - BOOST_CONTRACT_EXT_PP_KEYWORD_UTILITY_IS_CHECK_ \ - )(cat_to_comma_prefix, tokens) - -// Precondition: A macro named `token-to-check ## cat_to_comma_postfix` must be -// #defined to expand to `,`. -// Precondition: tokens must end with a token concatenable to a macro name -// (e.g., a literal or integral token) and trailing parenthesis -// are NOT allowed. -#define BOOST_CONTRACT_EXT_PP_KEYWORD_UTILITY_IS_BACK( \ - cat_to_comma_postfix, tokens) \ - BOOST_CONTRACT_EXT_PP_KEYWORD_UTILITY_IS_CHECK_( \ - tokens, cat_to_comma_postfix) +// (e.g., a literal or integral token). +#define BOOST_CONTRACT_AUX_PP_KEYWORD_UTILITY_IS(cat_to_comma_prefix, tokens) \ + BOOST_PP_CAT(BOOST_CONTRACT_AUX_PP_KEYWORD_UTILITY_IS_, \ + BOOST_PP_VARIADIC_SIZE(BOOST_PP_CAT(cat_to_comma_prefix, tokens))) /* PRIVATE */ -#define BOOST_CONTRACT_EXT_PP_KEYWORD_UTILITY_IS_FRONT_PAREN_( \ - cat_to_comma_prefix, tokens) \ - -#define BOOST_CONTRACT_EXT_PP_KEYWORD_UTILITY_IS_CHECK_(a, b) \ - BOOST_PP_CAT(BOOST_CONTRACT_EXT_PP_KEYWORD_UTILITY_IS_, \ - BOOST_PP_VARIADIC_SIZE(BOOST_PP_CAT(a, b))) - -#define BOOST_CONTRACT_EXT_PP_KEYWORD_UTILITY_IS_1 0 -#define BOOST_CONTRACT_EXT_PP_KEYWORD_UTILITY_IS_2 1 +#define BOOST_CONTRACT_AUX_PP_KEYWORD_UTILITY_IS_1 0 +#define BOOST_CONTRACT_AUX_PP_KEYWORD_UTILITY_IS_2 1 #endif // #include guard diff --git a/include/boost/contract/aux_/preprocessor/keyword/utility/remove.hpp b/include/boost/contract/aux_/preprocessor/keyword/utility/remove.hpp deleted file mode 100644 index 2cb6c90..0000000 --- a/include/boost/contract/aux_/preprocessor/keyword/utility/remove.hpp +++ /dev/null @@ -1,38 +0,0 @@ - -#ifndef BOOST_CONTRACT_EXT_PP_KEYWROD_REMOVE_HPP_ -#define BOOST_CONTRACT_EXT_PP_KEYWROD_REMOVE_HPP_ - -#include - -/* PUBLIC */ - -// Precondition: A macro named `cat_to_empty_prefix ## token-to-remove` must be -// #defined to expand to empty ``. -// Precondition: tokens must start with the token to be removed (this can be -// checked with `..._IS_..._FRONT` macros). -#define BOOST_CONTRACT_EXT_PP_KEYWORD_UTILITY_REMOVE_FRONT( \ - cat_to_empty_prefix, tokens) \ - BOOST_CONTRACT_EXT_PP_KEYWORD_UTILITY_REMOVE_CAT_( \ - cat_to_empty_prefix, tokens) - -// Precondition: A macro named `token-to-remove ## cat_to_empty_postfix` must be -// #defined to expand to empty ``. -// Precondition: tokens must end with the token to be removed (this can be -// checked with `..._IS_..._BACK` macros). -#define BOOST_CONTRACT_EXT_PP_KEYWORD_UTILITY_REMOVE_BACK( \ - cat_to_empty_postfix, tokens) \ - BOOST_CONTRACT_EXT_PP_KEYWORD_UTILITY_REMOVE_CAT_( \ - tokens, cat_to_empty_postfix) - -/* PRIVATE */ - -// Extra level of indirection needed for proper macro expansion (on MSVC). -#define BOOST_CONTRACT_EXT_PP_KEYWORD_UTILITY_REMOVE_CAT_(a, b) \ - BOOST_CONTRACT_EXT_PP_KEYWORD_UTILITY_REMOVE_EXPAND_( \ - BOOST_PP_CAT(a, b)) - -// Extra level of indirection needed for proper macro expansion (on MSVC). -#define BOOST_CONTRACT_EXT_PP_KEYWORD_UTILITY_REMOVE_EXPAND_(x) x - -#endif // #include guard - diff --git a/include/boost/contract/aux_/preprocessor/keyword/virtual.hpp b/include/boost/contract/aux_/preprocessor/keyword/virtual.hpp index b45e413..0af327d 100644 --- a/include/boost/contract/aux_/preprocessor/keyword/virtual.hpp +++ b/include/boost/contract/aux_/preprocessor/keyword/virtual.hpp @@ -1,48 +1,28 @@ -#ifndef BOOST_CONTRACT_EXT_PP_KEYWORD_VIRTUAL_HPP_ -#define BOOST_CONTRACT_EXT_PP_KEYWORD_VIRTUAL_HPP_ +#ifndef BOOST_CONTRACT_AUX_PP_KEYWORD_VIRTUAL_HPP_ +#define BOOST_CONTRACT_AUX_PP_KEYWORD_VIRTUAL_HPP_ -// WARNING: FILE AUTOMATICALLY GENERATED, DO NOT MODIFY IT! -// Instead, modify and run related generation script "keyword-generate.py". - -#include -#include +#include /* PUBLIC */ // Precondition: tokens must start with a token concatenable to a macro name -// (e.g., a literal or integral token) or with parenthesis. -#define BOOST_CONTRACT_EXT_PP_KEYWORD_IS_VIRTUAL_FRONT(tokens) \ - BOOST_CONTRACT_EXT_PP_KEYWORD_UTILITY_IS_FRONT( \ - BOOST_CONTRACT_EXT_PP_KEYWORD_VIRTUAL_CAT_TO_COMMA, tokens) - -// Precondition: tokens must end with a token concatenable to a macro name -// (e.g., a literal or integral token) or with parenthesis. -#define BOOST_CONTRACT_EXT_PP_KEYWORD_IS_VIRTUAL_BACK(tokens) \ - BOOST_CONTRACT_EXT_PP_KEYWORD_UTILITY_IS_BACK( \ - BOOST_CONTRACT_EXT_PP_KEYWORD_VIRTUAL_CAT_TO_COMMA, tokens) +// (e.g., a literal or integral token). +#define BOOST_CONTRACT_AUX_PP_KEYWORD_IS_VIRTUAL(tokens) \ + BOOST_CONTRACT_AUX_PP_KEYWORD_UTILITY_IS( \ + BOOST_CONTRACT_AUX_PP_KEYWORD_VIRTUAL_CAT_TO_COMMA, tokens) // Precondition: tokens must start with `virtual` (this can be -// checked with `..._IS_VIRTUAL_FRONT` macro above). -#define BOOST_CONTRACT_EXT_PP_KEYWORD_VIRTUAL_REMOVE_FRONT(tokens) \ - BOOST_CONTRACT_EXT_PP_KEYWORD_UTILITY_REMOVE_FRONT( \ - BOOST_CONTRACT_EXT_PP_KEYWORD_VIRTUAL_CAT_TO_EMPTY, tokens) - -// Precondition: tokens must end with `virtual` (this can be -// checked with `..._IS_VIRTUAL_BACK` macro above). -#define BOOST_CONTRACT_EXT_PP_KEYWORD_VIRTUAL_REMOVE_BACK(tokens) \ - BOOST_CONTRACT_EXT_PP_KEYWORD_UTILITY_REMOVE_BACK( \ - BOOST_CONTRACT_EXT_PP_KEYWORD_VIRTUAL_CAT_TO_EMPTY, tokens) +// checked with `..._IS_VIRTUAL` macro above). +#define BOOST_CONTRACT_AUX_PP_KEYWORD_REMOVE_VIRTUAL(tokens) \ + BOOST_PP_CAT(BOOST_CONTRACT_AUX_PP_KEYWORD_VIRTUAL_CAT_TO_EMPTY, tokens) /* PRIVATE */ // Must expand to a single comma `,` (not local macros, do not #undefine). -#define BOOST_CONTRACT_EXT_PP_KEYWORD_VIRTUAL_CAT_TO_COMMAvirtual , -#define virtualBOOST_CONTRACT_EXT_PP_KEYWORD_VIRTUAL_CAT_TO_COMMA , - +#define BOOST_CONTRACT_AUX_PP_KEYWORD_VIRTUAL_CAT_TO_COMMAvirtual , // Must expand to empty `` (not local macros, do not #undefine). -#define BOOST_CONTRACT_EXT_PP_KEYWORD_VIRTUAL_CAT_TO_EMPTYvirtual -#define virtualBOOST_CONTRACT_EXT_PP_KEYWORD_VIRTUAL_CAT_TO_EMPTY +#define BOOST_CONTRACT_AUX_PP_KEYWORD_VIRTUAL_CAT_TO_EMPTYvirtual #endif // #include guard diff --git a/include/boost/contract/aux_/sfinae.hpp b/include/boost/contract/aux_/sfinae.hpp deleted file mode 100644 index e7c4152..0000000 --- a/include/boost/contract/aux_/sfinae.hpp +++ /dev/null @@ -1,34 +0,0 @@ - -#ifndef BOOST_CONTRACT_EXT_SFINAE_HPP_ -#define BOOST_CONTRACT_EXT_SFINAE_HPP_ - -#include - -// NOTE: Unfortunately, it is not possible to use Boost.TTI because it not -// always works on MSVC (e.g., when the introspecting meta-function is invoked -// multiple times, MSVC 2010 gives an internal compiler error). This is a -// simpler implementation of SFINAE that can be used to program introspecing -// meta-functions that seem to work better with MSVC. - -namespace boost { namespace contract { namespace ext { namespace sfinae { - -typedef struct {} yes; -typedef yes no[2]; - -template -class check : private Check { - using Check::apply; - template static no& apply(...); - -public: - static bool const value = sizeof(apply(0)) == sizeof(yes); - typedef boost::mpl::bool_ type; -}; - -template< typename F, F > -struct function_exists; - -} } } } // namespace - -#endif // #include guard - diff --git a/include/boost/contract/aux_/tti.hpp b/include/boost/contract/aux_/tti.hpp new file mode 100644 index 0000000..c7af7ce --- /dev/null +++ b/include/boost/contract/aux_/tti.hpp @@ -0,0 +1,107 @@ + +#ifndef BOOST_CONTRACT_AUX_TTI_HPP_ +#define BOOST_CONTRACT_AUX_TTI_HPP_ + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// NOTE: Unfortunately, it is not possible to use Boost.TTI because it not +// always works on MSVC (e.g., when the introspecting meta-function is invoked +// multiple times, MSVC 2010 gives an internal compiler error). This is a +// simpler introspecting implementation that seem to work better with MSVC. + +/* PUBLIC */ + +#define BOOST_CONTRACT_AUX_TTI_TRAIT_HAS_TYPE(trait, type_name) \ + template \ + class trait { \ + template \ + static boost::contract::aux::tti::yes& check(typename \ + BOOST_CONTRACT_AUX_NAME1(C)::type_name*); \ + \ + BOOST_CONTRACT_AUX_TTI_TRAIT_END_(BOOST_CONTRACT_AUX_NAME1(T)) \ + }; + +#define BOOST_CONTRACT_AUX_TTI_TRAIT_HAS_MEMBER_FUNCTION(trait, func_name) \ + BOOST_CONTRACT_AUX_TTI_TRAIT_HAS_MEMBER_FUNCTION_(/* is_static = */ 0, \ + trait, func_name) + +#define BOOST_CONTRACT_AUX_TTI_TRAIT_HAS_STATIC_MEMBER_FUNCTION(trait, \ + func_name) \ + BOOST_CONTRACT_AUX_TTI_TRAIT_HAS_MEMBER_FUNCTION_(/* is_static = */ 1, \ + trait, func_name) + +/* PRIVATE */ + +#define BOOST_CONTRACT_AUX_TTI_TRAIT_HAS_MEMBER_FUNCTION_(is_static, trait, \ + func_name) \ + template< \ + typename BOOST_CONTRACT_AUX_NAME1(T), \ + typename BOOST_CONTRACT_AUX_NAME1(R), \ + class BOOST_CONTRACT_AUX_NAME1(P), \ + class BOOST_CONTRACT_AUX_NAME1(G) = boost::function_types::null_tag \ + > \ + class trait { \ + template \ + static boost::contract::aux::tti::yes& check( \ + boost::contract::aux::tti::check_function< \ + typename \ + BOOST_PP_IIF(is_static, \ + boost::function_types::function_pointer \ + , \ + boost::function_types::member_function_pointer \ + ) \ + < \ + typename boost::mpl::push_front< \ + BOOST_PP_IIF(is_static, \ + BOOST_CONTRACT_AUX_NAME1(P) \ + BOOST_PP_TUPLE_EAT(2) \ + , \ + BOOST_PP_TUPLE_REM(2) \ + )( \ + typename boost::mpl::push_front< \ + BOOST_CONTRACT_AUX_NAME1(P), \ + BOOST_CONTRACT_AUX_NAME1(C) \ + >::type \ + ) \ + , BOOST_CONTRACT_AUX_NAME1(R) \ + >::type, \ + BOOST_CONTRACT_AUX_NAME1(G) \ + >::type, \ + &BOOST_CONTRACT_AUX_NAME1(C)::func_name \ + >* \ + ); \ + \ + BOOST_CONTRACT_AUX_TTI_TRAIT_END_(BOOST_CONTRACT_AUX_NAME1(T)) \ + }; + +#define BOOST_CONTRACT_AUX_TTI_TRAIT_END_(tparam) \ + template \ + static boost::contract::aux::tti::no& check(...); \ + \ + public: \ + static bool const value = sizeof(check(0)) == \ + sizeof(boost::contract::aux::tti::yes); \ + typedef boost::mpl::bool_ type; + +/* CODE */ + +namespace boost { namespace contract { namespace aux { namespace tti { + +typedef struct {} yes; +typedef yes no[2]; + +template +struct check_function; + +} } } } // namespace + +#endif // #include guard + diff --git a/include/boost/contract/base_types.hpp b/include/boost/contract/base_types.hpp index 1ffaf31..af8d1e7 100644 --- a/include/boost/contract/base_types.hpp +++ b/include/boost/contract/base_types.hpp @@ -4,53 +4,137 @@ #include #if !BOOST_PP_VARIADICS -# define BOOST_CONTRACT_BASE_TYPES ERROR_variadic_macros_required_by_BOOST_CONTRACT_BASE_TYPES_consider_programming_base_typedef_manually_without_this_macro +# define BOOST_CONTRACT_BASE_TYPES ERROR_variadic_macros_required_by_BOOST_CONTRACT_BASE_TYPES_otherwise_manually_program_base_types #else -#include -#include -#include -#include -#include +#include +#include +#include +#include +#include +#include +#include +#include +#include #include -#include +#include +#include +#include +#include #include -#include +#include /* PUBLIC */ -// If no variadics macros, users have to manually program -// `typedef boost::mpl::vector<...> BOOST_CONTRACT_BASES`. #define BOOST_CONTRACT_BASE_TYPES(...) \ - boost::mpl::vector< \ - BOOST_PP_SEQ_FOR_EACH_I(BOOST_CONTRACT_BASE_TYPES_, ~, \ - BOOST_PP_VARIADIC_TO_SEQ(__VA_ARGS__)) \ - > + BOOST_CONTRACT_BASE_TYPES_CHECK_((__VA_ARGS__), \ + BOOST_PP_VARIADIC_TO_SEQ(__VA_ARGS__)) /* PRIVATE */ -#define BOOST_CONTRACT_BASE_TYPES_(r, unused, i, base) \ - BOOST_PP_COMMA_IF(i) \ - BOOST_CONTRACT_BASE_TYPES_REMOVE_( \ - BOOST_CONTRACT_EXT_PP_KEYWORD_IS_VIRTUAL_FRONT, \ - BOOST_CONTRACT_EXT_PP_KEYWORD_VIRTUAL_REMOVE_FRONT, \ - BOOST_CONTRACT_BASE_TYPES_REMOVE_( \ - BOOST_CONTRACT_EXT_PP_KEYWORD_IS_PUBLIC_FRONT, \ - BOOST_CONTRACT_EXT_PP_KEYWORD_PUBLIC_REMOVE_FRONT, \ - BOOST_CONTRACT_BASE_TYPES_REMOVE_( \ - BOOST_CONTRACT_EXT_PP_KEYWORD_IS_PROTECTED_FRONT, \ - BOOST_CONTRACT_EXT_PP_KEYWORD_PROTECTED_REMOVE_FRONT, \ - BOOST_CONTRACT_BASE_TYPES_REMOVE_( \ - BOOST_CONTRACT_EXT_PP_KEYWORD_IS_PRIVATE_FRONT, \ - BOOST_CONTRACT_EXT_PP_KEYWORD_PRIVATE_REMOVE_FRONT, \ - BOOST_CONTRACT_BASE_TYPES_REMOVE_( \ - BOOST_CONTRACT_EXT_PP_KEYWORD_IS_VIRTUAL_FRONT, \ - BOOST_CONTRACT_EXT_PP_KEYWORD_VIRTUAL_REMOVE_FRONT, \ - base \ - ))))) +// Cannot check that all base types have access specifiers (unless users have to +// specify bases using pp-seq, because user specified base list can have +// unwrapped commas between bases but also within a given base type, when base +// types are templates), but at least check the very first base type explicitly +// specifies access `[virtual] public | protected | private [virtual] ...`. +#define BOOST_CONTRACT_BASE_TYPES_CHECK_(bases_tuple, bases_seq) \ + BOOST_PP_IIF(BOOST_CONTRACT_BASE_TYPES_IS_ACCESS_( \ + BOOST_CONTRACT_BASE_TYPES_REMOVE_VIRTUAL_(BOOST_PP_SEQ_HEAD( \ + bases_seq))), \ + BOOST_CONTRACT_BASE_TYPES_OK_ \ + , \ + BOOST_CONTRACT_BASE_TYPES_ERR_ \ + )(bases_tuple, bases_seq) -#define BOOST_CONTRACT_BASE_TYPES_REMOVE_(is_macro, remove_macro, tokens) \ - BOOST_PP_IIF(is_macro(tokens), remove_macro, BOOST_PP_TUPLE_REM(1))(tokens) +// TODO: Make sure all compile-time error names read BOOST_CONTRACT_ERROR_... +// (not just ERROR_... because that's not reserved for this library use). + +#define BOOST_CONTRACT_BASE_TYPES_ERR_(bases_tuple, bases_seq) \ + BOOST_CONTRACT_ERROR_all_bases_must_explicitly_specify_public_protected_or_private base_tuple + +#define BOOST_CONTRACT_BASE_TYPES_OK_(base_tuple, bases_seq) \ + boost::mpl::vector< \ + BOOST_CONTRACT_BASE_TYPES_RETURN_(BOOST_PP_TUPLE_ELEM(2, 1, \ + BOOST_PP_SEQ_FOLD_LEFT( \ + BOOST_CONTRACT_BASE_TYPES_, \ + (0, (BOOST_PP_NIL)), \ + bases_seq \ + ) \ + )) \ + > + +#define BOOST_CONTRACT_BASE_TYPES_RETURN_(types_nilseq) \ + BOOST_PP_IIF(BOOST_PP_EQUAL(BOOST_PP_SEQ_SIZE(types_nilseq), 1), \ + BOOST_PP_TUPLE_EAT(1) \ + , \ + BOOST_CONTRACT_BASE_TYPES_RETURN_YES_ \ + )(types_nilseq) + +#define BOOST_CONTRACT_BASE_TYPES_RETURN_YES_(types_nilseq) \ + BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TAIL(types_nilseq)) + +#define BOOST_CONTRACT_BASE_TYPES_(s, public_types, base) \ + BOOST_CONTRACT_BASE_TYPES_ACCESS_( \ + BOOST_PP_TUPLE_ELEM(2, 0, public_types), \ + BOOST_PP_TUPLE_ELEM(2, 1, public_types), \ + BOOST_CONTRACT_BASE_TYPES_REMOVE_VIRTUAL_(base) \ + ) + +#define BOOST_CONTRACT_BASE_TYPES_ACCESS_(is_public, types_nilseq, base) \ + BOOST_PP_IIF(BOOST_CONTRACT_AUX_PP_KEYWORD_IS_PUBLIC(base), \ + BOOST_CONTRACT_BASE_TYPES_PUSH_BACK_PUBLIC_ \ + , BOOST_PP_IIF(BOOST_CONTRACT_AUX_PP_KEYWORD_IS_PROTECTED(base), \ + BOOST_CONTRACT_BASE_TYPES_SKIP_NOT_PUBLIC_ \ + , BOOST_PP_IIF(BOOST_CONTRACT_AUX_PP_KEYWORD_IS_PRIVATE(base), \ + BOOST_CONTRACT_BASE_TYPES_SKIP_NOT_PUBLIC_ \ + , \ + BOOST_CONTRACT_BASE_TYPES_PUSH_BACK_IF_ \ + )))(is_public, types_nilseq, base) + +// Precondition: base = `public [virtual] ...`. +#define BOOST_CONTRACT_BASE_TYPES_PUSH_BACK_PUBLIC_(is_public, types_nilseq, \ + base) \ + ( \ + 1, \ + BOOST_PP_SEQ_PUSH_BACK(types_nilseq, \ + BOOST_CONTRACT_BASE_TYPES_REMOVE_VIRTUAL_( \ + BOOST_CONTRACT_AUX_PP_KEYWORD_REMOVE_PUBLIC(base)) \ + ) \ + ) + +#define BOOST_CONTRACT_BASE_TYPES_SKIP_NOT_PUBLIC_(is_public, types_nilseq, \ + base) \ + (0, types_nilseq) + +#define BOOST_CONTRACT_BASE_TYPES_PUSH_BACK_IF_(is_public, types_nilseq, base) \ + ( \ + is_public, \ + BOOST_PP_IIF(is_public, \ + BOOST_PP_SEQ_PUSH_BACK \ + , \ + types_nilseq BOOST_PP_TUPLE_EAT(2) \ + )(types_nilseq, base) \ + ) + +#define BOOST_CONTRACT_BASE_TYPES_REMOVE_VIRTUAL_(base) \ + BOOST_PP_EXPAND( \ + BOOST_PP_IIF(BOOST_CONTRACT_AUX_PP_KEYWORD_IS_VIRTUAL(base), \ + BOOST_CONTRACT_AUX_PP_KEYWORD_REMOVE_VIRTUAL \ + , \ + BOOST_PP_TUPLE_REM(1) \ + )(base) \ + ) + +#define BOOST_CONTRACT_BASE_TYPES_IS_ACCESS_(base) \ + BOOST_PP_IIF(BOOST_CONTRACT_AUX_PP_KEYWORD_IS_PUBLIC(base), \ + 1 \ + , BOOST_PP_IIF(BOOST_CONTRACT_AUX_PP_KEYWORD_IS_PROTECTED(base), \ + 1 \ + , BOOST_PP_IIF(BOOST_CONTRACT_AUX_PP_KEYWORD_IS_PRIVATE(base), \ + 1 \ + , \ + 0 \ + ))) #endif // BOOST_PP_VARIADICS diff --git a/include/boost/contract/constructor.hpp b/include/boost/contract/constructor.hpp index b8c0a96..a561996 100644 --- a/include/boost/contract/constructor.hpp +++ b/include/boost/contract/constructor.hpp @@ -3,11 +3,21 @@ #define BOOST_CONTRACT_CONSTRUCTOR_HPP_ #include +#include #include #include namespace boost { namespace contract { +// Uses Class tparam to avoid multiple inheritance from same type. +template +struct constructor_precondition { + constructor_precondition() {} // For overloaded constructors with no pre. + + template + explicit constructor_precondition(Precondition const& f) { f(); } +}; + template boost::contract::type constructor(Class* const object) { return boost::contract::type( diff --git a/include/boost/contract/destructor.hpp b/include/boost/contract/destructor.hpp index 2b1af88..6df2562 100644 --- a/include/boost/contract/destructor.hpp +++ b/include/boost/contract/destructor.hpp @@ -3,6 +3,7 @@ #define BOOST_CONTRACT_DESTRUCTOR_HPP_ #include +#include #include #include diff --git a/include/boost/contract/introspect.hpp b/include/boost/contract/introspect.hpp index da38e16..9b36767 100644 --- a/include/boost/contract/introspect.hpp +++ b/include/boost/contract/introspect.hpp @@ -2,56 +2,24 @@ #ifndef BOOST_CONTRACT_INTROSPECT_HPP_ #define BOOST_CONTRACT_INTROSPECT_HPP_ +#include #include -#include -#include #include /* PUBLIC */ #define BOOST_CONTRACT_INTROSPECT(function_name) \ - BOOST_CONTRACT_NAMED_INTROSPECT(BOOST_PP_CAT(introspect_, function_name), \ + BOOST_CONTRACT_TRAIT_INTROSPECT(BOOST_PP_CAT(introspect_, function_name), \ function_name) -#define BOOST_CONTRACT_NAMED_INTROSPECT(introspect_name, function_name) \ - class introspect_name { \ - template< \ - typename BOOST_CONTRACT_AUX_NAME1(R), \ - class BOOST_CONTRACT_AUX_NAME1(P) \ - > \ - struct BOOST_CONTRACT_AUX_NAME1(has) { \ - template< typename BOOST_CONTRACT_AUX_NAME1(C) > \ - static boost::contract::ext::sfinae::yes& apply ( \ - boost::contract::ext::sfinae::function_exists< \ - typename boost::function_types::member_function_pointer< \ - typename boost::mpl::push_front< \ - typename boost::mpl::push_front< \ - BOOST_CONTRACT_AUX_NAME1(P), \ - BOOST_CONTRACT_AUX_NAME1(C) \ - >::type, \ - BOOST_CONTRACT_AUX_NAME1(R) \ - >::type \ - >::type, \ - &BOOST_CONTRACT_AUX_NAME1(C)::function_name \ - >* \ - ); \ - }; \ +#define BOOST_CONTRACT_TRAIT_INTROSPECT(trait_name, function_name) \ + struct trait_name { \ + BOOST_CONTRACT_AUX_TTI_TRAIT_HAS_MEMBER_FUNCTION(has_member_function, \ + function_name) \ \ - public:\ - template< \ - class BOOST_CONTRACT_AUX_NAME1(C), \ - typename BOOST_CONTRACT_AUX_NAME1(R), \ - class BOOST_CONTRACT_AUX_NAME1(P) \ - > \ - struct has_member_function : boost::contract::ext::sfinae::check< \ - BOOST_CONTRACT_AUX_NAME1(C), \ - BOOST_CONTRACT_AUX_NAME1(has) \ - > {}; \ - \ - template< class BOOST_CONTRACT_AUX_NAME1(C), \ - typename BOOST_CONTRACT_AUX_NAME1(F) > \ - static BOOST_CONTRACT_AUX_NAME1(F) member_function_address ( ) { \ + template \ + static BOOST_CONTRACT_AUX_NAME1(F) member_function_address() { \ return &BOOST_CONTRACT_AUX_NAME1(C)::function_name; \ } \ }; diff --git a/include/boost/contract/precondition.hpp b/include/boost/contract/precondition.hpp deleted file mode 100644 index 0d9b2d1..0000000 --- a/include/boost/contract/precondition.hpp +++ /dev/null @@ -1,16 +0,0 @@ - -#ifndef BOOST_CONTRACT_PRECONDITION_HPP_ -#define BOOST_CONTRACT_PRECONDITION_HPP_ - -namespace boost { namespace contract { - -template -struct precondition { - template - explicit preconfition(Precondition const& f) { f(); } -}; - -} } // namespace - -#endif // #include guard - diff --git a/include/boost/contract/public_member.hpp b/include/boost/contract/public_member.hpp index 0b63597..c18080f 100644 --- a/include/boost/contract/public_member.hpp +++ b/include/boost/contract/public_member.hpp @@ -10,6 +10,29 @@ // TODO: On C++11 Clang... these could static_assert enclosing func is pub? +// TODO: Consider providing also macros like: +// void push_back(T const& value, boost::contract::virtual_back v = 0) { +// unsigned const old_size = v.oldof_(size()); +// BOOST_CONTRACT_PUBLIC_MEMBER(this, &vector::push_back, value, v) +// .precondition(...) +// .postcondition(...) +// ; +// ... +// } +// These macros should take the exact same params as their related functions +// (allowing param overloading via variadic macros) so to avoid confusion for +// the user in using macros instead of function-based APIs. +// The real benefit of these macros is that with C++14 generic lambdas they +// do not require users to also call BOOST_CONTRACT_INTROSPECT(push_back)! +// Also, with C++11 constexpr and __func__ (but also __FUNCTION__), these macros +// can check the specified function name is correct (matching +// `&.*::__func__` == `&vector::push_back`). +// So these macros could be always provided, they will double check the function +// name only on C++11 constexpr + __func__, and the will not require the +// external call to BOOST_CONTRACT_INTROSPECT only on C++14 generic lambdas (so +// even if they are always provided, they become truly useful and more prowerful +// on on C++14 generic lambdas when compared to the function-base APIs). + namespace boost { namespace contract { // Contract for public member functions with a virtual body and members of a diff --git a/test/Jamfile.v2 b/test/Jamfile.v2 index 0826a09..1a1dcbb 100644 --- a/test/Jamfile.v2 +++ b/test/Jamfile.v2 @@ -1,66 +1,13 @@ -echo """Usage: - Compile and run test file /.cpp: [implicit] - $ bjam / ... - - Preprocess file /.cpp (stop at preprocessed traits, -UDEBUG to - generate all C++ test code instead): [explicit] - $ bjam /-pp [cxxflags=-UDEBUG] ... - - Preprocess file /.cpp using Boost.Wave (instead of toolset's - preprocessor): [explicit] - $ bjam /-wave ... -""" ; - import testing ; -actions wave { wave $(>) -o $(<) --timer } - -rule test-pp ( dir file ) { - run $(dir)/$(file).cpp : : : $(dir) : $(dir)/$(file) ; - - preprocessed $(dir)/$(file)-pp : $(dir)/$(file).cpp : - $(dir) -DDEBUG ; - alias $(dir)/$(file)-pp.ii : $(dir)/$(file)-pp ; - explicit $(dir)/$(file)-pp $(dir)/$(file)-pp.ii ; - - # TODO: It'd be nice to automatically run the generate.py before building - # using something like `bjam --generate ...` or `bjam generate ...`. - # TODO: It'd be nice to run all ...-wave targets at once using something - # like `bjam wave ...` or `bjam --wave ...`. - make $(dir)/$(file)-wave.ii : $(dir)/$(file).cpp : @wave ; - alias $(dir)/$(file)-wave : $(dir)/$(file)-wave.ii ; - explicit $(dir)/$(file)-wave $(dir)/$(file)-wave.ii ; -} - -test-pp pp_func_traits access ; -test-pp pp_func_traits verbatim ; -test-pp pp_func_traits export ; -test-pp pp_func_traits template ; -test-pp pp_func_traits classifiers ; -test-pp pp_func_traits return_ ; -test-pp pp_func_traits name ; -test-pp pp_func_traits params ; -test-pp pp_func_traits cv ; -test-pp pp_func_traits ref ; -test-pp pp_func_traits except ; -test-pp pp_func_traits trailing_return ; -test-pp pp_func_traits virt ; -test-pp pp_func_traits preconditions ; -test-pp pp_func_traits postconditions ; - -test-pp pp_class_traits export ; -test-pp pp_class_traits template ; -test-pp pp_class_traits friend ; -test-pp pp_class_traits key ; -test-pp pp_class_traits verbatim ; -test-pp pp_class_traits name ; -test-pp pp_class_traits specialization ; -test-pp pp_class_traits virt ; -test-pp pp_class_traits bases ; - -test-pp subcontracting inheritance_level3_multi2 ; - -run public_member_bases_v.cpp ; +run base_types.cpp ; +run has_bases.cpp ; +run has_invariant.cpp ; +run introspect.cpp ; +run constructor_bases.cpp ; +run destructor_bases.cpp ; +run public_member_bases_virtual.cpp ; +run public_member_bases_static.cpp ; diff --git a/test/aux_/oteststream.hpp b/test/aux_/oteststream.hpp new file mode 100644 index 0000000..650e73e --- /dev/null +++ b/test/aux_/oteststream.hpp @@ -0,0 +1,63 @@ + +#ifndef BOOST_CONTRACT_AUX_TEST_OTESTSTREAM_HPP_ +#define BOOST_CONTRACT_AUX_TEST_OTESTSTREAM_HPP_ + +#include +#include +#include +#include +#include + +namespace boost { namespace contract { namespace aux { namespace test { + +namespace oteststream_ { + struct oss_base { // Wrap oss data member for proper initialization order. + protected: + std::ostringstream oss_; + }; +} + +// Print to clog plus build internal string (like ostringstream) for checking. +struct oteststream : + private oteststream_::oss_base, + public boost::iostreams::stream > +{ + oteststream() : + oteststream_::oss_base(), + boost::iostreams::stream >( + boost::iostreams::tee_device( + std::clog, oss_) + ) + {} + + std::string str() const { return oss_.str(); } + void str(std::string const& s) { oss_.str(s); } + + // If found, display mismatching character. + bool check(std::string const& s) { + std::string r = str(); + std::string::size_type i = 0; + for(; i < r.size() && i < s.size(); ++i) if(r[i] != s[i]) break; + if(i < r.size() || i < s.size()) { + std::cout << std::endl; + std::cout << + "Error: Following strings differ at position " << i << + ", because '" << r[i] << "' != '" << s[i] << "':" << std::endl + ; + std::cout << std::endl; + std::cout << r.substr(0, std::min(i + 1, r.size())) << std::endl; + std::cout << std::endl; + std::cout << s.substr(0, std::min(i + 1, s.size())) << std::endl; + std::cout << std::endl; + return false; + } + return true; + } +}; + +} } } } // namespace + +#endif // #include guard + diff --git a/test/aux_/pp_1tuple_rem.hpp b/test/aux_/pp_1tuple_rem.hpp deleted file mode 100644 index 799513f..0000000 --- a/test/aux_/pp_1tuple_rem.hpp +++ /dev/null @@ -1,35 +0,0 @@ - -#ifndef BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM_HPP_ -#define BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM_HPP_ - -#include -#include -#include -#include -#include -#include -#include - -/* PUBLIC */ - -// Expand `(x)` to x, but `x` (no parenthesis) to `x` and `(x, ...)` (tuple -// size > `) to `(x, ...)`. -#define BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM(tuple) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_HAS_PAREN(tuple), \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM_ \ - , \ - BOOST_PP_TUPLE_REM(1) \ - )(tuple) - -/* PRIVATE */ - -#define BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM_(tuple) \ - BOOST_PP_EXPAND( \ - BOOST_PP_EXPR_IIF(BOOST_PP_EQUAL(BOOST_PP_TUPLE_SIZE(tuple), 1), \ - BOOST_PP_TUPLE_REM(1) \ - ) \ - tuple \ - ) - -#endif // #include guard - diff --git a/test/aux_/pp_assertions-generate.py b/test/aux_/pp_assertions-generate.py deleted file mode 100644 index 76d463c..0000000 --- a/test/aux_/pp_assertions-generate.py +++ /dev/null @@ -1,263 +0,0 @@ - -import os -import sys - -LIMIT = 64 - -def code(): - result = '' - for n in range(1, LIMIT + 1): - result = result + ''' -/* PUBLIC ({0}) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_{0}( \\ - s, assertions, assertion_traits) \\ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_{0}_(s, assertions, \\ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_{0}_, assertion_traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_{0}( \\ - s, assertions, assertion_traits) \\ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_{0}_(s, assertions, \\ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_{0}_, assertion_traits) - -/* PRIVATE ({0}) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_{0}_( \\ - s, assertions, assertion_macro, assertion_traits) \\ - ( \\ - BOOST_PP_TUPLE_REM_CTOR(assertions) \\ - assertion_macro(s, assertion_traits) \\ - ) - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_{0}_(s, traits) \\ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_NAMESPACE_FRONT( \\ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \\ - BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_{0}_ \\ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_USING_FRONT( \\ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \\ - BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_{0}_ \\ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_TYPEDEF_FRONT( \\ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \\ - BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_{0}_ \\ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \\ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \\ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_{0}_ \\ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \\ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \\ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_{0}_ \\ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \\ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \\ - BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_{0}_ \\ - , \\ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_{0}_ \\ - ))))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_{0}_(s, traits) \\ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_RETURN_FRONT( \\ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \\ - BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_{0}_ \\ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_IS( \\ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \\ - BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_{0}_ \\ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \\ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \\ - BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_{0}_ \\ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \\ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \\ - BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_{0}_ \\ - , \\ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_{0}_ \\ - ))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_{0}_(s, traits) \\ - namespace \\ - (BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NEW_NAME(traits)) \\ - as BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NAME(traits) \\ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_{0}_(s, traits) \\ - BOOST_PP_EXPR_IIF( \\ - BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \\ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS( \\ - traits \\ - ) \\ - )) \\ - , \\ - template \\ - ) \\ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS(traits) \\ - using \\ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAMESPACE(traits) \\ - BOOST_PP_EXPR_IIF(BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \\ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits))), \\ - (BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits)) as \\ - ) \\ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \\ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAME(traits)) \\ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_{0}_(s, traits) \\ - typedef \\ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \\ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NAME(traits)) \\ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NEW_NAME(traits) \\ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_{0}_(s, traits) \\ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_{0}_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_{0}_(s, traits, \\ - has_trailing_comma) \\ - const \\ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \\ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)), \\ - () BOOST_PP_TUPLE_EAT(3) \\ - , \\ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \\ - )(BOOST_CONTRACT_TEST_AUX_PP_CAPTURE_S_, (), \\ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)) \\ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_EXPR(traits) \\ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_{0}_(s, traits) \\ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_{0}_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_{0}_(s, traits, \\ - has_trailing_comma) \\ - BOOST_CONTRACT_EXT_PP_BOOL_ASSERTION_TRAITS_EXPR(traits) \\ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_{0}_(s, traits) \\ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_{0}_(s, traits, 0, \\ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_{1}) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_{0}_(s, traits) \\ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_{0}_(s, traits, 0, \\ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_{1}) - -#define BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_{0}_(s, traits) \\ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_{0}_(s, traits, 1, \\ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_{1}) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_{0}_(s, traits) \\ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_{0}_(s, traits, 1, \\ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_{1}) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_{0}_(s, traits, \\ - is_static, next_assertion_macro) \\ - BOOST_PP_EXPR_IIF(is_static, static) \\ - if( \\ - BOOST_PP_IIF( \\ - BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \\ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY( \\ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND( \\ - traits \\ - ))) \\ - , \\ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_{1}_ \\ - , \\ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_{1}_ \\ - )(s, BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND(traits), 0) \\ - ) \\ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \\ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)), \\ - ( ) BOOST_PP_TUPLE_EAT(3) \\ - , \\ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \\ - )(next_assertion_macro, (), \\ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)) \\ - else \\ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \\ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)), \\ - ( ) BOOST_PP_TUPLE_EAT(3) \\ - , \\ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \\ - )(next_assertion_macro, (), \\ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)) - -// Extra parenthesis always internally added for if bool cond (so remove them). -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_{0}_(s, \\ - cond_traits, has_trailing_comma) \\ - BOOST_PP_TUPLE_REM_CTOR( \ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_{0}_( \\ - s, cond_traits, has_trailing_comma) \ - ) - -#define BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_{0}_(s, traits) \\ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \\ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_TYPE(traits)) \\ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_ASSIGN(traits) \\ - return \\ - , - -// Implementation: OLDOF_..._OPERATOR internally splits tokens into a 2-tuple. -#define BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_{0}_(s, traits) \\ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \\ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_TYPE(traits)) \\ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_ASSIGN(traits) \\ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_OPERATOR \\ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_EXPR(traits) \\ - , -'''.format(n, n + 1) - return result - -script = os.path.basename(sys.argv[0]) -path = sys.argv[0].replace('-generate.py', '', 1) + ".hpp" -file = open(path, 'w') - -file.write(''' -#ifndef BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_HPP_ -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_HPP_ - -// WARNING: FILE AUTOMATICALLY GENERATED, DO NOT MODIFY IT! -// Instead, modify and run related generation script "{0}". - -#include "pp_1tuple_rem.hpp" -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -/* PIBLIC */ - -// Maximum number of nested assertions that can be processed (before pp errors). -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_LIMIT {1} - -/* PRIVATE */ - -#define BOOST_CONTRACT_TEST_AUX_PP_CAPTURE_S_(s, captures, traits) \\ - BOOST_CONTRACT_TEST_AUX_PP_CAPTURE_PUSH_BACK_( \\ - captures, \\ - ( \\ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \\ - BOOST_CONTRACT_EXT_PP_CAPTURE_TRAITS_TYPE(traits)) \\ - BOOST_CONTRACT_EXT_PP_CAPTURE_TRAITS_NAME(traits) \\ - ) \\ - ) - -#define BOOST_CONTRACT_TEST_AUX_PP_CAPTURE_PUSH_BACK_(captures, capture) \ - ( \ - BOOST_PP_TUPLE_REM_CTOR(captures) \ - BOOST_PP_COMMA_IF(BOOST_PP_COMPL( \ - BOOST_PP_EXPAND(BOOST_CONTRACT_EXT_PP_IS_EMPTY captures))) \ - BOOST_PP_TUPLE_REM_CTOR(capture) \ - ) -{2} -#endif // #include guard -'''.format(script, LIMIT, code())) - -file.close() -print "Written:", path - - diff --git a/test/aux_/pp_assertions.hpp b/test/aux_/pp_assertions.hpp deleted file mode 100644 index 60bb387..0000000 --- a/test/aux_/pp_assertions.hpp +++ /dev/null @@ -1,12140 +0,0 @@ - -#ifndef BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_HPP_ -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_HPP_ - -// WARNING: FILE AUTOMATICALLY GENERATED, DO NOT MODIFY IT! -// Instead, modify and run related generation script "pp_assertions-generate.py". - -#include "pp_1tuple_rem.hpp" -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -/* PIBLIC */ - -// Maximum number of nested assertions that can be processed (before pp errors). -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_LIMIT 64 - -/* PRIVATE */ - -#define BOOST_CONTRACT_TEST_AUX_PP_CAPTURE_S_(s, captures, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_CAPTURE_PUSH_BACK_( \ - captures, \ - ( \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_CAPTURE_TRAITS_TYPE(traits)) \ - BOOST_CONTRACT_EXT_PP_CAPTURE_TRAITS_NAME(traits) \ - ) \ - ) - -#define BOOST_CONTRACT_TEST_AUX_PP_CAPTURE_PUSH_BACK_(captures, capture) ( BOOST_PP_TUPLE_REM_CTOR(captures) BOOST_PP_COMMA_IF(BOOST_PP_COMPL( BOOST_PP_EXPAND(BOOST_CONTRACT_EXT_PP_IS_EMPTY captures))) BOOST_PP_TUPLE_REM_CTOR(capture) ) - -/* PUBLIC (1) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_1( \ - s, assertions, assertion_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_1_(s, assertions, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_1_, assertion_traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_1( \ - s, assertions, assertion_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_1_(s, assertions, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_1_, assertion_traits) - -/* PRIVATE (1) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_1_( \ - s, assertions, assertion_macro, assertion_traits) \ - ( \ - BOOST_PP_TUPLE_REM_CTOR(assertions) \ - assertion_macro(s, assertion_traits) \ - ) - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_1_(s, traits) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_NAMESPACE_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_1_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_USING_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_1_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_TYPEDEF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_1_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_1_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_1_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_1_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_1_ \ - ))))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_1_(s, traits) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_RETURN_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_1_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_1_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_1_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_1_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_1_ \ - ))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_1_(s, traits) \ - namespace \ - (BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NEW_NAME(traits)) \ - as BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NAME(traits) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_1_(s, traits) \ - BOOST_PP_EXPR_IIF( \ - BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS( \ - traits \ - ) \ - )) \ - , \ - template \ - ) \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS(traits) \ - using \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAMESPACE(traits) \ - BOOST_PP_EXPR_IIF(BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits))), \ - (BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits)) as \ - ) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAME(traits)) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_1_(s, traits) \ - typedef \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NAME(traits)) \ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NEW_NAME(traits) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_1_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_1_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_1_(s, traits, \ - has_trailing_comma) \ - const \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)), \ - () BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(BOOST_CONTRACT_TEST_AUX_PP_CAPTURE_S_, (), \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)) \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_EXPR(traits) \ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_1_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_1_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_1_(s, traits, \ - has_trailing_comma) \ - BOOST_CONTRACT_EXT_PP_BOOL_ASSERTION_TRAITS_EXPR(traits) \ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_1_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_1_(s, traits, 0, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_2) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_1_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_1_(s, traits, 0, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_2) - -#define BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_1_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_1_(s, traits, 1, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_2) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_1_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_1_(s, traits, 1, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_2) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_1_(s, traits, \ - is_static, next_assertion_macro) \ - BOOST_PP_EXPR_IIF(is_static, static) \ - if( \ - BOOST_PP_IIF( \ - BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND( \ - traits \ - ))) \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_2_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_2_ \ - )(s, BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND(traits), 0) \ - ) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)), \ - ( ) BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(next_assertion_macro, (), \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)) \ - else \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)), \ - ( ) BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(next_assertion_macro, (), \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)) - -// Extra parenthesis always internally added for if bool cond (so remove them). -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_1_(s, \ - cond_traits, has_trailing_comma) \ - BOOST_PP_TUPLE_REM_CTOR( BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_1_( \ - s, cond_traits, has_trailing_comma) ) - -#define BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_1_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_TYPE(traits)) \ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_ASSIGN(traits) \ - return \ - , - -// Implementation: OLDOF_..._OPERATOR internally splits tokens into a 2-tuple. -#define BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_1_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_TYPE(traits)) \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_ASSIGN(traits) \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_OPERATOR \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_EXPR(traits) \ - , - -/* PUBLIC (2) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_2( \ - s, assertions, assertion_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_2_(s, assertions, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_2_, assertion_traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_2( \ - s, assertions, assertion_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_2_(s, assertions, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_2_, assertion_traits) - -/* PRIVATE (2) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_2_( \ - s, assertions, assertion_macro, assertion_traits) \ - ( \ - BOOST_PP_TUPLE_REM_CTOR(assertions) \ - assertion_macro(s, assertion_traits) \ - ) - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_2_(s, traits) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_NAMESPACE_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_2_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_USING_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_2_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_TYPEDEF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_2_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_2_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_2_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_2_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_2_ \ - ))))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_2_(s, traits) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_RETURN_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_2_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_2_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_2_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_2_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_2_ \ - ))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_2_(s, traits) \ - namespace \ - (BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NEW_NAME(traits)) \ - as BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NAME(traits) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_2_(s, traits) \ - BOOST_PP_EXPR_IIF( \ - BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS( \ - traits \ - ) \ - )) \ - , \ - template \ - ) \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS(traits) \ - using \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAMESPACE(traits) \ - BOOST_PP_EXPR_IIF(BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits))), \ - (BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits)) as \ - ) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAME(traits)) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_2_(s, traits) \ - typedef \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NAME(traits)) \ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NEW_NAME(traits) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_2_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_2_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_2_(s, traits, \ - has_trailing_comma) \ - const \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)), \ - () BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(BOOST_CONTRACT_TEST_AUX_PP_CAPTURE_S_, (), \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)) \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_EXPR(traits) \ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_2_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_2_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_2_(s, traits, \ - has_trailing_comma) \ - BOOST_CONTRACT_EXT_PP_BOOL_ASSERTION_TRAITS_EXPR(traits) \ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_2_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_2_(s, traits, 0, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_3) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_2_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_2_(s, traits, 0, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_3) - -#define BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_2_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_2_(s, traits, 1, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_3) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_2_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_2_(s, traits, 1, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_3) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_2_(s, traits, \ - is_static, next_assertion_macro) \ - BOOST_PP_EXPR_IIF(is_static, static) \ - if( \ - BOOST_PP_IIF( \ - BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND( \ - traits \ - ))) \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_3_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_3_ \ - )(s, BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND(traits), 0) \ - ) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)), \ - ( ) BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(next_assertion_macro, (), \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)) \ - else \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)), \ - ( ) BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(next_assertion_macro, (), \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)) - -// Extra parenthesis always internally added for if bool cond (so remove them). -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_2_(s, \ - cond_traits, has_trailing_comma) \ - BOOST_PP_TUPLE_REM_CTOR( BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_2_( \ - s, cond_traits, has_trailing_comma) ) - -#define BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_2_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_TYPE(traits)) \ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_ASSIGN(traits) \ - return \ - , - -// Implementation: OLDOF_..._OPERATOR internally splits tokens into a 2-tuple. -#define BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_2_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_TYPE(traits)) \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_ASSIGN(traits) \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_OPERATOR \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_EXPR(traits) \ - , - -/* PUBLIC (3) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_3( \ - s, assertions, assertion_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_3_(s, assertions, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_3_, assertion_traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_3( \ - s, assertions, assertion_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_3_(s, assertions, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_3_, assertion_traits) - -/* PRIVATE (3) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_3_( \ - s, assertions, assertion_macro, assertion_traits) \ - ( \ - BOOST_PP_TUPLE_REM_CTOR(assertions) \ - assertion_macro(s, assertion_traits) \ - ) - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_3_(s, traits) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_NAMESPACE_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_3_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_USING_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_3_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_TYPEDEF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_3_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_3_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_3_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_3_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_3_ \ - ))))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_3_(s, traits) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_RETURN_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_3_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_3_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_3_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_3_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_3_ \ - ))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_3_(s, traits) \ - namespace \ - (BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NEW_NAME(traits)) \ - as BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NAME(traits) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_3_(s, traits) \ - BOOST_PP_EXPR_IIF( \ - BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS( \ - traits \ - ) \ - )) \ - , \ - template \ - ) \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS(traits) \ - using \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAMESPACE(traits) \ - BOOST_PP_EXPR_IIF(BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits))), \ - (BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits)) as \ - ) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAME(traits)) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_3_(s, traits) \ - typedef \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NAME(traits)) \ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NEW_NAME(traits) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_3_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_3_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_3_(s, traits, \ - has_trailing_comma) \ - const \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)), \ - () BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(BOOST_CONTRACT_TEST_AUX_PP_CAPTURE_S_, (), \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)) \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_EXPR(traits) \ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_3_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_3_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_3_(s, traits, \ - has_trailing_comma) \ - BOOST_CONTRACT_EXT_PP_BOOL_ASSERTION_TRAITS_EXPR(traits) \ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_3_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_3_(s, traits, 0, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_4) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_3_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_3_(s, traits, 0, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_4) - -#define BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_3_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_3_(s, traits, 1, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_4) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_3_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_3_(s, traits, 1, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_4) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_3_(s, traits, \ - is_static, next_assertion_macro) \ - BOOST_PP_EXPR_IIF(is_static, static) \ - if( \ - BOOST_PP_IIF( \ - BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND( \ - traits \ - ))) \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_4_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_4_ \ - )(s, BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND(traits), 0) \ - ) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)), \ - ( ) BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(next_assertion_macro, (), \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)) \ - else \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)), \ - ( ) BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(next_assertion_macro, (), \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)) - -// Extra parenthesis always internally added for if bool cond (so remove them). -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_3_(s, \ - cond_traits, has_trailing_comma) \ - BOOST_PP_TUPLE_REM_CTOR( BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_3_( \ - s, cond_traits, has_trailing_comma) ) - -#define BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_3_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_TYPE(traits)) \ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_ASSIGN(traits) \ - return \ - , - -// Implementation: OLDOF_..._OPERATOR internally splits tokens into a 2-tuple. -#define BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_3_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_TYPE(traits)) \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_ASSIGN(traits) \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_OPERATOR \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_EXPR(traits) \ - , - -/* PUBLIC (4) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_4( \ - s, assertions, assertion_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_4_(s, assertions, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_4_, assertion_traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_4( \ - s, assertions, assertion_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_4_(s, assertions, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_4_, assertion_traits) - -/* PRIVATE (4) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_4_( \ - s, assertions, assertion_macro, assertion_traits) \ - ( \ - BOOST_PP_TUPLE_REM_CTOR(assertions) \ - assertion_macro(s, assertion_traits) \ - ) - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_4_(s, traits) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_NAMESPACE_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_4_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_USING_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_4_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_TYPEDEF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_4_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_4_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_4_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_4_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_4_ \ - ))))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_4_(s, traits) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_RETURN_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_4_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_4_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_4_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_4_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_4_ \ - ))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_4_(s, traits) \ - namespace \ - (BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NEW_NAME(traits)) \ - as BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NAME(traits) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_4_(s, traits) \ - BOOST_PP_EXPR_IIF( \ - BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS( \ - traits \ - ) \ - )) \ - , \ - template \ - ) \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS(traits) \ - using \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAMESPACE(traits) \ - BOOST_PP_EXPR_IIF(BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits))), \ - (BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits)) as \ - ) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAME(traits)) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_4_(s, traits) \ - typedef \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NAME(traits)) \ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NEW_NAME(traits) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_4_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_4_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_4_(s, traits, \ - has_trailing_comma) \ - const \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)), \ - () BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(BOOST_CONTRACT_TEST_AUX_PP_CAPTURE_S_, (), \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)) \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_EXPR(traits) \ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_4_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_4_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_4_(s, traits, \ - has_trailing_comma) \ - BOOST_CONTRACT_EXT_PP_BOOL_ASSERTION_TRAITS_EXPR(traits) \ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_4_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_4_(s, traits, 0, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_5) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_4_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_4_(s, traits, 0, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_5) - -#define BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_4_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_4_(s, traits, 1, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_5) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_4_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_4_(s, traits, 1, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_5) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_4_(s, traits, \ - is_static, next_assertion_macro) \ - BOOST_PP_EXPR_IIF(is_static, static) \ - if( \ - BOOST_PP_IIF( \ - BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND( \ - traits \ - ))) \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_5_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_5_ \ - )(s, BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND(traits), 0) \ - ) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)), \ - ( ) BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(next_assertion_macro, (), \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)) \ - else \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)), \ - ( ) BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(next_assertion_macro, (), \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)) - -// Extra parenthesis always internally added for if bool cond (so remove them). -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_4_(s, \ - cond_traits, has_trailing_comma) \ - BOOST_PP_TUPLE_REM_CTOR( BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_4_( \ - s, cond_traits, has_trailing_comma) ) - -#define BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_4_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_TYPE(traits)) \ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_ASSIGN(traits) \ - return \ - , - -// Implementation: OLDOF_..._OPERATOR internally splits tokens into a 2-tuple. -#define BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_4_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_TYPE(traits)) \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_ASSIGN(traits) \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_OPERATOR \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_EXPR(traits) \ - , - -/* PUBLIC (5) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_5( \ - s, assertions, assertion_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_5_(s, assertions, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_5_, assertion_traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_5( \ - s, assertions, assertion_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_5_(s, assertions, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_5_, assertion_traits) - -/* PRIVATE (5) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_5_( \ - s, assertions, assertion_macro, assertion_traits) \ - ( \ - BOOST_PP_TUPLE_REM_CTOR(assertions) \ - assertion_macro(s, assertion_traits) \ - ) - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_5_(s, traits) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_NAMESPACE_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_5_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_USING_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_5_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_TYPEDEF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_5_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_5_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_5_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_5_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_5_ \ - ))))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_5_(s, traits) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_RETURN_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_5_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_5_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_5_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_5_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_5_ \ - ))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_5_(s, traits) \ - namespace \ - (BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NEW_NAME(traits)) \ - as BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NAME(traits) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_5_(s, traits) \ - BOOST_PP_EXPR_IIF( \ - BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS( \ - traits \ - ) \ - )) \ - , \ - template \ - ) \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS(traits) \ - using \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAMESPACE(traits) \ - BOOST_PP_EXPR_IIF(BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits))), \ - (BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits)) as \ - ) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAME(traits)) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_5_(s, traits) \ - typedef \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NAME(traits)) \ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NEW_NAME(traits) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_5_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_5_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_5_(s, traits, \ - has_trailing_comma) \ - const \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)), \ - () BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(BOOST_CONTRACT_TEST_AUX_PP_CAPTURE_S_, (), \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)) \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_EXPR(traits) \ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_5_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_5_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_5_(s, traits, \ - has_trailing_comma) \ - BOOST_CONTRACT_EXT_PP_BOOL_ASSERTION_TRAITS_EXPR(traits) \ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_5_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_5_(s, traits, 0, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_6) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_5_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_5_(s, traits, 0, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_6) - -#define BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_5_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_5_(s, traits, 1, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_6) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_5_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_5_(s, traits, 1, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_6) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_5_(s, traits, \ - is_static, next_assertion_macro) \ - BOOST_PP_EXPR_IIF(is_static, static) \ - if( \ - BOOST_PP_IIF( \ - BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND( \ - traits \ - ))) \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_6_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_6_ \ - )(s, BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND(traits), 0) \ - ) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)), \ - ( ) BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(next_assertion_macro, (), \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)) \ - else \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)), \ - ( ) BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(next_assertion_macro, (), \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)) - -// Extra parenthesis always internally added for if bool cond (so remove them). -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_5_(s, \ - cond_traits, has_trailing_comma) \ - BOOST_PP_TUPLE_REM_CTOR( BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_5_( \ - s, cond_traits, has_trailing_comma) ) - -#define BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_5_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_TYPE(traits)) \ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_ASSIGN(traits) \ - return \ - , - -// Implementation: OLDOF_..._OPERATOR internally splits tokens into a 2-tuple. -#define BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_5_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_TYPE(traits)) \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_ASSIGN(traits) \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_OPERATOR \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_EXPR(traits) \ - , - -/* PUBLIC (6) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_6( \ - s, assertions, assertion_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_6_(s, assertions, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_6_, assertion_traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_6( \ - s, assertions, assertion_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_6_(s, assertions, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_6_, assertion_traits) - -/* PRIVATE (6) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_6_( \ - s, assertions, assertion_macro, assertion_traits) \ - ( \ - BOOST_PP_TUPLE_REM_CTOR(assertions) \ - assertion_macro(s, assertion_traits) \ - ) - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_6_(s, traits) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_NAMESPACE_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_6_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_USING_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_6_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_TYPEDEF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_6_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_6_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_6_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_6_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_6_ \ - ))))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_6_(s, traits) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_RETURN_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_6_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_6_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_6_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_6_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_6_ \ - ))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_6_(s, traits) \ - namespace \ - (BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NEW_NAME(traits)) \ - as BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NAME(traits) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_6_(s, traits) \ - BOOST_PP_EXPR_IIF( \ - BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS( \ - traits \ - ) \ - )) \ - , \ - template \ - ) \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS(traits) \ - using \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAMESPACE(traits) \ - BOOST_PP_EXPR_IIF(BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits))), \ - (BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits)) as \ - ) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAME(traits)) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_6_(s, traits) \ - typedef \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NAME(traits)) \ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NEW_NAME(traits) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_6_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_6_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_6_(s, traits, \ - has_trailing_comma) \ - const \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)), \ - () BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(BOOST_CONTRACT_TEST_AUX_PP_CAPTURE_S_, (), \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)) \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_EXPR(traits) \ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_6_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_6_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_6_(s, traits, \ - has_trailing_comma) \ - BOOST_CONTRACT_EXT_PP_BOOL_ASSERTION_TRAITS_EXPR(traits) \ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_6_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_6_(s, traits, 0, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_7) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_6_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_6_(s, traits, 0, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_7) - -#define BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_6_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_6_(s, traits, 1, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_7) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_6_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_6_(s, traits, 1, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_7) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_6_(s, traits, \ - is_static, next_assertion_macro) \ - BOOST_PP_EXPR_IIF(is_static, static) \ - if( \ - BOOST_PP_IIF( \ - BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND( \ - traits \ - ))) \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_7_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_7_ \ - )(s, BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND(traits), 0) \ - ) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)), \ - ( ) BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(next_assertion_macro, (), \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)) \ - else \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)), \ - ( ) BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(next_assertion_macro, (), \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)) - -// Extra parenthesis always internally added for if bool cond (so remove them). -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_6_(s, \ - cond_traits, has_trailing_comma) \ - BOOST_PP_TUPLE_REM_CTOR( BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_6_( \ - s, cond_traits, has_trailing_comma) ) - -#define BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_6_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_TYPE(traits)) \ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_ASSIGN(traits) \ - return \ - , - -// Implementation: OLDOF_..._OPERATOR internally splits tokens into a 2-tuple. -#define BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_6_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_TYPE(traits)) \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_ASSIGN(traits) \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_OPERATOR \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_EXPR(traits) \ - , - -/* PUBLIC (7) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_7( \ - s, assertions, assertion_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_7_(s, assertions, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_7_, assertion_traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_7( \ - s, assertions, assertion_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_7_(s, assertions, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_7_, assertion_traits) - -/* PRIVATE (7) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_7_( \ - s, assertions, assertion_macro, assertion_traits) \ - ( \ - BOOST_PP_TUPLE_REM_CTOR(assertions) \ - assertion_macro(s, assertion_traits) \ - ) - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_7_(s, traits) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_NAMESPACE_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_7_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_USING_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_7_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_TYPEDEF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_7_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_7_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_7_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_7_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_7_ \ - ))))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_7_(s, traits) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_RETURN_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_7_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_7_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_7_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_7_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_7_ \ - ))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_7_(s, traits) \ - namespace \ - (BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NEW_NAME(traits)) \ - as BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NAME(traits) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_7_(s, traits) \ - BOOST_PP_EXPR_IIF( \ - BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS( \ - traits \ - ) \ - )) \ - , \ - template \ - ) \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS(traits) \ - using \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAMESPACE(traits) \ - BOOST_PP_EXPR_IIF(BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits))), \ - (BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits)) as \ - ) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAME(traits)) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_7_(s, traits) \ - typedef \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NAME(traits)) \ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NEW_NAME(traits) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_7_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_7_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_7_(s, traits, \ - has_trailing_comma) \ - const \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)), \ - () BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(BOOST_CONTRACT_TEST_AUX_PP_CAPTURE_S_, (), \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)) \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_EXPR(traits) \ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_7_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_7_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_7_(s, traits, \ - has_trailing_comma) \ - BOOST_CONTRACT_EXT_PP_BOOL_ASSERTION_TRAITS_EXPR(traits) \ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_7_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_7_(s, traits, 0, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_8) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_7_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_7_(s, traits, 0, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_8) - -#define BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_7_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_7_(s, traits, 1, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_8) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_7_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_7_(s, traits, 1, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_8) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_7_(s, traits, \ - is_static, next_assertion_macro) \ - BOOST_PP_EXPR_IIF(is_static, static) \ - if( \ - BOOST_PP_IIF( \ - BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND( \ - traits \ - ))) \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_8_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_8_ \ - )(s, BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND(traits), 0) \ - ) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)), \ - ( ) BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(next_assertion_macro, (), \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)) \ - else \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)), \ - ( ) BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(next_assertion_macro, (), \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)) - -// Extra parenthesis always internally added for if bool cond (so remove them). -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_7_(s, \ - cond_traits, has_trailing_comma) \ - BOOST_PP_TUPLE_REM_CTOR( BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_7_( \ - s, cond_traits, has_trailing_comma) ) - -#define BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_7_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_TYPE(traits)) \ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_ASSIGN(traits) \ - return \ - , - -// Implementation: OLDOF_..._OPERATOR internally splits tokens into a 2-tuple. -#define BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_7_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_TYPE(traits)) \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_ASSIGN(traits) \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_OPERATOR \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_EXPR(traits) \ - , - -/* PUBLIC (8) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_8( \ - s, assertions, assertion_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_8_(s, assertions, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_8_, assertion_traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_8( \ - s, assertions, assertion_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_8_(s, assertions, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_8_, assertion_traits) - -/* PRIVATE (8) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_8_( \ - s, assertions, assertion_macro, assertion_traits) \ - ( \ - BOOST_PP_TUPLE_REM_CTOR(assertions) \ - assertion_macro(s, assertion_traits) \ - ) - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_8_(s, traits) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_NAMESPACE_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_8_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_USING_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_8_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_TYPEDEF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_8_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_8_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_8_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_8_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_8_ \ - ))))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_8_(s, traits) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_RETURN_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_8_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_8_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_8_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_8_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_8_ \ - ))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_8_(s, traits) \ - namespace \ - (BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NEW_NAME(traits)) \ - as BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NAME(traits) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_8_(s, traits) \ - BOOST_PP_EXPR_IIF( \ - BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS( \ - traits \ - ) \ - )) \ - , \ - template \ - ) \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS(traits) \ - using \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAMESPACE(traits) \ - BOOST_PP_EXPR_IIF(BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits))), \ - (BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits)) as \ - ) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAME(traits)) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_8_(s, traits) \ - typedef \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NAME(traits)) \ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NEW_NAME(traits) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_8_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_8_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_8_(s, traits, \ - has_trailing_comma) \ - const \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)), \ - () BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(BOOST_CONTRACT_TEST_AUX_PP_CAPTURE_S_, (), \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)) \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_EXPR(traits) \ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_8_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_8_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_8_(s, traits, \ - has_trailing_comma) \ - BOOST_CONTRACT_EXT_PP_BOOL_ASSERTION_TRAITS_EXPR(traits) \ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_8_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_8_(s, traits, 0, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_9) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_8_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_8_(s, traits, 0, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_9) - -#define BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_8_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_8_(s, traits, 1, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_9) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_8_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_8_(s, traits, 1, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_9) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_8_(s, traits, \ - is_static, next_assertion_macro) \ - BOOST_PP_EXPR_IIF(is_static, static) \ - if( \ - BOOST_PP_IIF( \ - BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND( \ - traits \ - ))) \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_9_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_9_ \ - )(s, BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND(traits), 0) \ - ) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)), \ - ( ) BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(next_assertion_macro, (), \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)) \ - else \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)), \ - ( ) BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(next_assertion_macro, (), \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)) - -// Extra parenthesis always internally added for if bool cond (so remove them). -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_8_(s, \ - cond_traits, has_trailing_comma) \ - BOOST_PP_TUPLE_REM_CTOR( BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_8_( \ - s, cond_traits, has_trailing_comma) ) - -#define BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_8_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_TYPE(traits)) \ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_ASSIGN(traits) \ - return \ - , - -// Implementation: OLDOF_..._OPERATOR internally splits tokens into a 2-tuple. -#define BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_8_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_TYPE(traits)) \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_ASSIGN(traits) \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_OPERATOR \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_EXPR(traits) \ - , - -/* PUBLIC (9) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_9( \ - s, assertions, assertion_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_9_(s, assertions, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_9_, assertion_traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_9( \ - s, assertions, assertion_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_9_(s, assertions, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_9_, assertion_traits) - -/* PRIVATE (9) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_9_( \ - s, assertions, assertion_macro, assertion_traits) \ - ( \ - BOOST_PP_TUPLE_REM_CTOR(assertions) \ - assertion_macro(s, assertion_traits) \ - ) - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_9_(s, traits) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_NAMESPACE_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_9_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_USING_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_9_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_TYPEDEF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_9_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_9_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_9_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_9_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_9_ \ - ))))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_9_(s, traits) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_RETURN_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_9_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_9_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_9_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_9_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_9_ \ - ))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_9_(s, traits) \ - namespace \ - (BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NEW_NAME(traits)) \ - as BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NAME(traits) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_9_(s, traits) \ - BOOST_PP_EXPR_IIF( \ - BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS( \ - traits \ - ) \ - )) \ - , \ - template \ - ) \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS(traits) \ - using \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAMESPACE(traits) \ - BOOST_PP_EXPR_IIF(BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits))), \ - (BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits)) as \ - ) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAME(traits)) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_9_(s, traits) \ - typedef \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NAME(traits)) \ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NEW_NAME(traits) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_9_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_9_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_9_(s, traits, \ - has_trailing_comma) \ - const \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)), \ - () BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(BOOST_CONTRACT_TEST_AUX_PP_CAPTURE_S_, (), \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)) \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_EXPR(traits) \ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_9_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_9_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_9_(s, traits, \ - has_trailing_comma) \ - BOOST_CONTRACT_EXT_PP_BOOL_ASSERTION_TRAITS_EXPR(traits) \ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_9_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_9_(s, traits, 0, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_10) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_9_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_9_(s, traits, 0, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_10) - -#define BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_9_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_9_(s, traits, 1, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_10) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_9_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_9_(s, traits, 1, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_10) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_9_(s, traits, \ - is_static, next_assertion_macro) \ - BOOST_PP_EXPR_IIF(is_static, static) \ - if( \ - BOOST_PP_IIF( \ - BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND( \ - traits \ - ))) \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_10_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_10_ \ - )(s, BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND(traits), 0) \ - ) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)), \ - ( ) BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(next_assertion_macro, (), \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)) \ - else \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)), \ - ( ) BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(next_assertion_macro, (), \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)) - -// Extra parenthesis always internally added for if bool cond (so remove them). -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_9_(s, \ - cond_traits, has_trailing_comma) \ - BOOST_PP_TUPLE_REM_CTOR( BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_9_( \ - s, cond_traits, has_trailing_comma) ) - -#define BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_9_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_TYPE(traits)) \ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_ASSIGN(traits) \ - return \ - , - -// Implementation: OLDOF_..._OPERATOR internally splits tokens into a 2-tuple. -#define BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_9_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_TYPE(traits)) \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_ASSIGN(traits) \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_OPERATOR \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_EXPR(traits) \ - , - -/* PUBLIC (10) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_10( \ - s, assertions, assertion_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_10_(s, assertions, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_10_, assertion_traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_10( \ - s, assertions, assertion_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_10_(s, assertions, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_10_, assertion_traits) - -/* PRIVATE (10) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_10_( \ - s, assertions, assertion_macro, assertion_traits) \ - ( \ - BOOST_PP_TUPLE_REM_CTOR(assertions) \ - assertion_macro(s, assertion_traits) \ - ) - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_10_(s, traits) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_NAMESPACE_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_10_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_USING_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_10_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_TYPEDEF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_10_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_10_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_10_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_10_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_10_ \ - ))))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_10_(s, traits) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_RETURN_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_10_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_10_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_10_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_10_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_10_ \ - ))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_10_(s, traits) \ - namespace \ - (BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NEW_NAME(traits)) \ - as BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NAME(traits) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_10_(s, traits) \ - BOOST_PP_EXPR_IIF( \ - BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS( \ - traits \ - ) \ - )) \ - , \ - template \ - ) \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS(traits) \ - using \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAMESPACE(traits) \ - BOOST_PP_EXPR_IIF(BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits))), \ - (BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits)) as \ - ) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAME(traits)) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_10_(s, traits) \ - typedef \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NAME(traits)) \ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NEW_NAME(traits) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_10_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_10_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_10_(s, traits, \ - has_trailing_comma) \ - const \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)), \ - () BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(BOOST_CONTRACT_TEST_AUX_PP_CAPTURE_S_, (), \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)) \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_EXPR(traits) \ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_10_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_10_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_10_(s, traits, \ - has_trailing_comma) \ - BOOST_CONTRACT_EXT_PP_BOOL_ASSERTION_TRAITS_EXPR(traits) \ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_10_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_10_(s, traits, 0, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_11) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_10_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_10_(s, traits, 0, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_11) - -#define BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_10_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_10_(s, traits, 1, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_11) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_10_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_10_(s, traits, 1, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_11) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_10_(s, traits, \ - is_static, next_assertion_macro) \ - BOOST_PP_EXPR_IIF(is_static, static) \ - if( \ - BOOST_PP_IIF( \ - BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND( \ - traits \ - ))) \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_11_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_11_ \ - )(s, BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND(traits), 0) \ - ) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)), \ - ( ) BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(next_assertion_macro, (), \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)) \ - else \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)), \ - ( ) BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(next_assertion_macro, (), \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)) - -// Extra parenthesis always internally added for if bool cond (so remove them). -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_10_(s, \ - cond_traits, has_trailing_comma) \ - BOOST_PP_TUPLE_REM_CTOR( BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_10_( \ - s, cond_traits, has_trailing_comma) ) - -#define BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_10_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_TYPE(traits)) \ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_ASSIGN(traits) \ - return \ - , - -// Implementation: OLDOF_..._OPERATOR internally splits tokens into a 2-tuple. -#define BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_10_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_TYPE(traits)) \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_ASSIGN(traits) \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_OPERATOR \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_EXPR(traits) \ - , - -/* PUBLIC (11) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_11( \ - s, assertions, assertion_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_11_(s, assertions, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_11_, assertion_traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_11( \ - s, assertions, assertion_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_11_(s, assertions, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_11_, assertion_traits) - -/* PRIVATE (11) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_11_( \ - s, assertions, assertion_macro, assertion_traits) \ - ( \ - BOOST_PP_TUPLE_REM_CTOR(assertions) \ - assertion_macro(s, assertion_traits) \ - ) - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_11_(s, traits) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_NAMESPACE_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_11_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_USING_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_11_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_TYPEDEF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_11_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_11_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_11_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_11_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_11_ \ - ))))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_11_(s, traits) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_RETURN_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_11_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_11_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_11_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_11_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_11_ \ - ))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_11_(s, traits) \ - namespace \ - (BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NEW_NAME(traits)) \ - as BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NAME(traits) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_11_(s, traits) \ - BOOST_PP_EXPR_IIF( \ - BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS( \ - traits \ - ) \ - )) \ - , \ - template \ - ) \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS(traits) \ - using \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAMESPACE(traits) \ - BOOST_PP_EXPR_IIF(BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits))), \ - (BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits)) as \ - ) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAME(traits)) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_11_(s, traits) \ - typedef \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NAME(traits)) \ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NEW_NAME(traits) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_11_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_11_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_11_(s, traits, \ - has_trailing_comma) \ - const \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)), \ - () BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(BOOST_CONTRACT_TEST_AUX_PP_CAPTURE_S_, (), \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)) \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_EXPR(traits) \ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_11_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_11_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_11_(s, traits, \ - has_trailing_comma) \ - BOOST_CONTRACT_EXT_PP_BOOL_ASSERTION_TRAITS_EXPR(traits) \ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_11_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_11_(s, traits, 0, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_12) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_11_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_11_(s, traits, 0, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_12) - -#define BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_11_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_11_(s, traits, 1, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_12) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_11_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_11_(s, traits, 1, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_12) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_11_(s, traits, \ - is_static, next_assertion_macro) \ - BOOST_PP_EXPR_IIF(is_static, static) \ - if( \ - BOOST_PP_IIF( \ - BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND( \ - traits \ - ))) \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_12_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_12_ \ - )(s, BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND(traits), 0) \ - ) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)), \ - ( ) BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(next_assertion_macro, (), \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)) \ - else \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)), \ - ( ) BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(next_assertion_macro, (), \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)) - -// Extra parenthesis always internally added for if bool cond (so remove them). -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_11_(s, \ - cond_traits, has_trailing_comma) \ - BOOST_PP_TUPLE_REM_CTOR( BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_11_( \ - s, cond_traits, has_trailing_comma) ) - -#define BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_11_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_TYPE(traits)) \ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_ASSIGN(traits) \ - return \ - , - -// Implementation: OLDOF_..._OPERATOR internally splits tokens into a 2-tuple. -#define BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_11_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_TYPE(traits)) \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_ASSIGN(traits) \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_OPERATOR \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_EXPR(traits) \ - , - -/* PUBLIC (12) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_12( \ - s, assertions, assertion_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_12_(s, assertions, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_12_, assertion_traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_12( \ - s, assertions, assertion_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_12_(s, assertions, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_12_, assertion_traits) - -/* PRIVATE (12) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_12_( \ - s, assertions, assertion_macro, assertion_traits) \ - ( \ - BOOST_PP_TUPLE_REM_CTOR(assertions) \ - assertion_macro(s, assertion_traits) \ - ) - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_12_(s, traits) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_NAMESPACE_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_12_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_USING_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_12_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_TYPEDEF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_12_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_12_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_12_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_12_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_12_ \ - ))))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_12_(s, traits) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_RETURN_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_12_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_12_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_12_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_12_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_12_ \ - ))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_12_(s, traits) \ - namespace \ - (BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NEW_NAME(traits)) \ - as BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NAME(traits) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_12_(s, traits) \ - BOOST_PP_EXPR_IIF( \ - BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS( \ - traits \ - ) \ - )) \ - , \ - template \ - ) \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS(traits) \ - using \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAMESPACE(traits) \ - BOOST_PP_EXPR_IIF(BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits))), \ - (BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits)) as \ - ) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAME(traits)) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_12_(s, traits) \ - typedef \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NAME(traits)) \ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NEW_NAME(traits) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_12_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_12_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_12_(s, traits, \ - has_trailing_comma) \ - const \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)), \ - () BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(BOOST_CONTRACT_TEST_AUX_PP_CAPTURE_S_, (), \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)) \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_EXPR(traits) \ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_12_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_12_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_12_(s, traits, \ - has_trailing_comma) \ - BOOST_CONTRACT_EXT_PP_BOOL_ASSERTION_TRAITS_EXPR(traits) \ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_12_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_12_(s, traits, 0, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_13) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_12_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_12_(s, traits, 0, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_13) - -#define BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_12_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_12_(s, traits, 1, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_13) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_12_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_12_(s, traits, 1, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_13) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_12_(s, traits, \ - is_static, next_assertion_macro) \ - BOOST_PP_EXPR_IIF(is_static, static) \ - if( \ - BOOST_PP_IIF( \ - BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND( \ - traits \ - ))) \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_13_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_13_ \ - )(s, BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND(traits), 0) \ - ) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)), \ - ( ) BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(next_assertion_macro, (), \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)) \ - else \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)), \ - ( ) BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(next_assertion_macro, (), \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)) - -// Extra parenthesis always internally added for if bool cond (so remove them). -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_12_(s, \ - cond_traits, has_trailing_comma) \ - BOOST_PP_TUPLE_REM_CTOR( BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_12_( \ - s, cond_traits, has_trailing_comma) ) - -#define BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_12_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_TYPE(traits)) \ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_ASSIGN(traits) \ - return \ - , - -// Implementation: OLDOF_..._OPERATOR internally splits tokens into a 2-tuple. -#define BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_12_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_TYPE(traits)) \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_ASSIGN(traits) \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_OPERATOR \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_EXPR(traits) \ - , - -/* PUBLIC (13) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_13( \ - s, assertions, assertion_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_13_(s, assertions, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_13_, assertion_traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_13( \ - s, assertions, assertion_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_13_(s, assertions, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_13_, assertion_traits) - -/* PRIVATE (13) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_13_( \ - s, assertions, assertion_macro, assertion_traits) \ - ( \ - BOOST_PP_TUPLE_REM_CTOR(assertions) \ - assertion_macro(s, assertion_traits) \ - ) - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_13_(s, traits) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_NAMESPACE_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_13_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_USING_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_13_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_TYPEDEF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_13_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_13_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_13_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_13_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_13_ \ - ))))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_13_(s, traits) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_RETURN_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_13_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_13_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_13_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_13_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_13_ \ - ))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_13_(s, traits) \ - namespace \ - (BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NEW_NAME(traits)) \ - as BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NAME(traits) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_13_(s, traits) \ - BOOST_PP_EXPR_IIF( \ - BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS( \ - traits \ - ) \ - )) \ - , \ - template \ - ) \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS(traits) \ - using \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAMESPACE(traits) \ - BOOST_PP_EXPR_IIF(BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits))), \ - (BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits)) as \ - ) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAME(traits)) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_13_(s, traits) \ - typedef \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NAME(traits)) \ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NEW_NAME(traits) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_13_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_13_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_13_(s, traits, \ - has_trailing_comma) \ - const \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)), \ - () BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(BOOST_CONTRACT_TEST_AUX_PP_CAPTURE_S_, (), \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)) \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_EXPR(traits) \ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_13_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_13_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_13_(s, traits, \ - has_trailing_comma) \ - BOOST_CONTRACT_EXT_PP_BOOL_ASSERTION_TRAITS_EXPR(traits) \ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_13_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_13_(s, traits, 0, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_14) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_13_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_13_(s, traits, 0, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_14) - -#define BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_13_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_13_(s, traits, 1, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_14) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_13_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_13_(s, traits, 1, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_14) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_13_(s, traits, \ - is_static, next_assertion_macro) \ - BOOST_PP_EXPR_IIF(is_static, static) \ - if( \ - BOOST_PP_IIF( \ - BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND( \ - traits \ - ))) \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_14_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_14_ \ - )(s, BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND(traits), 0) \ - ) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)), \ - ( ) BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(next_assertion_macro, (), \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)) \ - else \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)), \ - ( ) BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(next_assertion_macro, (), \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)) - -// Extra parenthesis always internally added for if bool cond (so remove them). -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_13_(s, \ - cond_traits, has_trailing_comma) \ - BOOST_PP_TUPLE_REM_CTOR( BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_13_( \ - s, cond_traits, has_trailing_comma) ) - -#define BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_13_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_TYPE(traits)) \ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_ASSIGN(traits) \ - return \ - , - -// Implementation: OLDOF_..._OPERATOR internally splits tokens into a 2-tuple. -#define BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_13_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_TYPE(traits)) \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_ASSIGN(traits) \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_OPERATOR \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_EXPR(traits) \ - , - -/* PUBLIC (14) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_14( \ - s, assertions, assertion_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_14_(s, assertions, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_14_, assertion_traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_14( \ - s, assertions, assertion_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_14_(s, assertions, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_14_, assertion_traits) - -/* PRIVATE (14) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_14_( \ - s, assertions, assertion_macro, assertion_traits) \ - ( \ - BOOST_PP_TUPLE_REM_CTOR(assertions) \ - assertion_macro(s, assertion_traits) \ - ) - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_14_(s, traits) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_NAMESPACE_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_14_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_USING_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_14_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_TYPEDEF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_14_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_14_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_14_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_14_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_14_ \ - ))))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_14_(s, traits) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_RETURN_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_14_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_14_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_14_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_14_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_14_ \ - ))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_14_(s, traits) \ - namespace \ - (BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NEW_NAME(traits)) \ - as BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NAME(traits) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_14_(s, traits) \ - BOOST_PP_EXPR_IIF( \ - BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS( \ - traits \ - ) \ - )) \ - , \ - template \ - ) \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS(traits) \ - using \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAMESPACE(traits) \ - BOOST_PP_EXPR_IIF(BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits))), \ - (BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits)) as \ - ) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAME(traits)) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_14_(s, traits) \ - typedef \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NAME(traits)) \ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NEW_NAME(traits) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_14_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_14_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_14_(s, traits, \ - has_trailing_comma) \ - const \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)), \ - () BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(BOOST_CONTRACT_TEST_AUX_PP_CAPTURE_S_, (), \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)) \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_EXPR(traits) \ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_14_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_14_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_14_(s, traits, \ - has_trailing_comma) \ - BOOST_CONTRACT_EXT_PP_BOOL_ASSERTION_TRAITS_EXPR(traits) \ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_14_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_14_(s, traits, 0, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_15) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_14_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_14_(s, traits, 0, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_15) - -#define BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_14_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_14_(s, traits, 1, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_15) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_14_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_14_(s, traits, 1, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_15) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_14_(s, traits, \ - is_static, next_assertion_macro) \ - BOOST_PP_EXPR_IIF(is_static, static) \ - if( \ - BOOST_PP_IIF( \ - BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND( \ - traits \ - ))) \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_15_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_15_ \ - )(s, BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND(traits), 0) \ - ) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)), \ - ( ) BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(next_assertion_macro, (), \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)) \ - else \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)), \ - ( ) BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(next_assertion_macro, (), \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)) - -// Extra parenthesis always internally added for if bool cond (so remove them). -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_14_(s, \ - cond_traits, has_trailing_comma) \ - BOOST_PP_TUPLE_REM_CTOR( BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_14_( \ - s, cond_traits, has_trailing_comma) ) - -#define BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_14_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_TYPE(traits)) \ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_ASSIGN(traits) \ - return \ - , - -// Implementation: OLDOF_..._OPERATOR internally splits tokens into a 2-tuple. -#define BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_14_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_TYPE(traits)) \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_ASSIGN(traits) \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_OPERATOR \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_EXPR(traits) \ - , - -/* PUBLIC (15) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_15( \ - s, assertions, assertion_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_15_(s, assertions, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_15_, assertion_traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_15( \ - s, assertions, assertion_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_15_(s, assertions, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_15_, assertion_traits) - -/* PRIVATE (15) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_15_( \ - s, assertions, assertion_macro, assertion_traits) \ - ( \ - BOOST_PP_TUPLE_REM_CTOR(assertions) \ - assertion_macro(s, assertion_traits) \ - ) - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_15_(s, traits) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_NAMESPACE_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_15_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_USING_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_15_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_TYPEDEF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_15_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_15_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_15_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_15_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_15_ \ - ))))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_15_(s, traits) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_RETURN_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_15_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_15_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_15_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_15_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_15_ \ - ))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_15_(s, traits) \ - namespace \ - (BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NEW_NAME(traits)) \ - as BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NAME(traits) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_15_(s, traits) \ - BOOST_PP_EXPR_IIF( \ - BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS( \ - traits \ - ) \ - )) \ - , \ - template \ - ) \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS(traits) \ - using \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAMESPACE(traits) \ - BOOST_PP_EXPR_IIF(BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits))), \ - (BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits)) as \ - ) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAME(traits)) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_15_(s, traits) \ - typedef \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NAME(traits)) \ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NEW_NAME(traits) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_15_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_15_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_15_(s, traits, \ - has_trailing_comma) \ - const \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)), \ - () BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(BOOST_CONTRACT_TEST_AUX_PP_CAPTURE_S_, (), \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)) \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_EXPR(traits) \ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_15_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_15_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_15_(s, traits, \ - has_trailing_comma) \ - BOOST_CONTRACT_EXT_PP_BOOL_ASSERTION_TRAITS_EXPR(traits) \ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_15_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_15_(s, traits, 0, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_16) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_15_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_15_(s, traits, 0, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_16) - -#define BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_15_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_15_(s, traits, 1, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_16) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_15_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_15_(s, traits, 1, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_16) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_15_(s, traits, \ - is_static, next_assertion_macro) \ - BOOST_PP_EXPR_IIF(is_static, static) \ - if( \ - BOOST_PP_IIF( \ - BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND( \ - traits \ - ))) \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_16_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_16_ \ - )(s, BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND(traits), 0) \ - ) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)), \ - ( ) BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(next_assertion_macro, (), \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)) \ - else \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)), \ - ( ) BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(next_assertion_macro, (), \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)) - -// Extra parenthesis always internally added for if bool cond (so remove them). -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_15_(s, \ - cond_traits, has_trailing_comma) \ - BOOST_PP_TUPLE_REM_CTOR( BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_15_( \ - s, cond_traits, has_trailing_comma) ) - -#define BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_15_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_TYPE(traits)) \ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_ASSIGN(traits) \ - return \ - , - -// Implementation: OLDOF_..._OPERATOR internally splits tokens into a 2-tuple. -#define BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_15_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_TYPE(traits)) \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_ASSIGN(traits) \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_OPERATOR \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_EXPR(traits) \ - , - -/* PUBLIC (16) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_16( \ - s, assertions, assertion_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_16_(s, assertions, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_16_, assertion_traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_16( \ - s, assertions, assertion_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_16_(s, assertions, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_16_, assertion_traits) - -/* PRIVATE (16) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_16_( \ - s, assertions, assertion_macro, assertion_traits) \ - ( \ - BOOST_PP_TUPLE_REM_CTOR(assertions) \ - assertion_macro(s, assertion_traits) \ - ) - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_16_(s, traits) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_NAMESPACE_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_16_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_USING_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_16_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_TYPEDEF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_16_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_16_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_16_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_16_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_16_ \ - ))))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_16_(s, traits) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_RETURN_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_16_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_16_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_16_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_16_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_16_ \ - ))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_16_(s, traits) \ - namespace \ - (BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NEW_NAME(traits)) \ - as BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NAME(traits) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_16_(s, traits) \ - BOOST_PP_EXPR_IIF( \ - BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS( \ - traits \ - ) \ - )) \ - , \ - template \ - ) \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS(traits) \ - using \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAMESPACE(traits) \ - BOOST_PP_EXPR_IIF(BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits))), \ - (BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits)) as \ - ) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAME(traits)) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_16_(s, traits) \ - typedef \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NAME(traits)) \ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NEW_NAME(traits) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_16_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_16_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_16_(s, traits, \ - has_trailing_comma) \ - const \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)), \ - () BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(BOOST_CONTRACT_TEST_AUX_PP_CAPTURE_S_, (), \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)) \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_EXPR(traits) \ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_16_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_16_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_16_(s, traits, \ - has_trailing_comma) \ - BOOST_CONTRACT_EXT_PP_BOOL_ASSERTION_TRAITS_EXPR(traits) \ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_16_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_16_(s, traits, 0, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_17) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_16_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_16_(s, traits, 0, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_17) - -#define BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_16_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_16_(s, traits, 1, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_17) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_16_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_16_(s, traits, 1, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_17) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_16_(s, traits, \ - is_static, next_assertion_macro) \ - BOOST_PP_EXPR_IIF(is_static, static) \ - if( \ - BOOST_PP_IIF( \ - BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND( \ - traits \ - ))) \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_17_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_17_ \ - )(s, BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND(traits), 0) \ - ) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)), \ - ( ) BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(next_assertion_macro, (), \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)) \ - else \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)), \ - ( ) BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(next_assertion_macro, (), \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)) - -// Extra parenthesis always internally added for if bool cond (so remove them). -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_16_(s, \ - cond_traits, has_trailing_comma) \ - BOOST_PP_TUPLE_REM_CTOR( BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_16_( \ - s, cond_traits, has_trailing_comma) ) - -#define BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_16_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_TYPE(traits)) \ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_ASSIGN(traits) \ - return \ - , - -// Implementation: OLDOF_..._OPERATOR internally splits tokens into a 2-tuple. -#define BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_16_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_TYPE(traits)) \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_ASSIGN(traits) \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_OPERATOR \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_EXPR(traits) \ - , - -/* PUBLIC (17) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_17( \ - s, assertions, assertion_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_17_(s, assertions, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_17_, assertion_traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_17( \ - s, assertions, assertion_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_17_(s, assertions, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_17_, assertion_traits) - -/* PRIVATE (17) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_17_( \ - s, assertions, assertion_macro, assertion_traits) \ - ( \ - BOOST_PP_TUPLE_REM_CTOR(assertions) \ - assertion_macro(s, assertion_traits) \ - ) - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_17_(s, traits) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_NAMESPACE_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_17_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_USING_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_17_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_TYPEDEF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_17_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_17_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_17_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_17_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_17_ \ - ))))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_17_(s, traits) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_RETURN_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_17_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_17_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_17_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_17_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_17_ \ - ))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_17_(s, traits) \ - namespace \ - (BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NEW_NAME(traits)) \ - as BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NAME(traits) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_17_(s, traits) \ - BOOST_PP_EXPR_IIF( \ - BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS( \ - traits \ - ) \ - )) \ - , \ - template \ - ) \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS(traits) \ - using \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAMESPACE(traits) \ - BOOST_PP_EXPR_IIF(BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits))), \ - (BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits)) as \ - ) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAME(traits)) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_17_(s, traits) \ - typedef \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NAME(traits)) \ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NEW_NAME(traits) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_17_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_17_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_17_(s, traits, \ - has_trailing_comma) \ - const \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)), \ - () BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(BOOST_CONTRACT_TEST_AUX_PP_CAPTURE_S_, (), \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)) \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_EXPR(traits) \ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_17_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_17_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_17_(s, traits, \ - has_trailing_comma) \ - BOOST_CONTRACT_EXT_PP_BOOL_ASSERTION_TRAITS_EXPR(traits) \ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_17_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_17_(s, traits, 0, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_18) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_17_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_17_(s, traits, 0, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_18) - -#define BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_17_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_17_(s, traits, 1, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_18) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_17_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_17_(s, traits, 1, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_18) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_17_(s, traits, \ - is_static, next_assertion_macro) \ - BOOST_PP_EXPR_IIF(is_static, static) \ - if( \ - BOOST_PP_IIF( \ - BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND( \ - traits \ - ))) \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_18_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_18_ \ - )(s, BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND(traits), 0) \ - ) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)), \ - ( ) BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(next_assertion_macro, (), \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)) \ - else \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)), \ - ( ) BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(next_assertion_macro, (), \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)) - -// Extra parenthesis always internally added for if bool cond (so remove them). -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_17_(s, \ - cond_traits, has_trailing_comma) \ - BOOST_PP_TUPLE_REM_CTOR( BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_17_( \ - s, cond_traits, has_trailing_comma) ) - -#define BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_17_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_TYPE(traits)) \ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_ASSIGN(traits) \ - return \ - , - -// Implementation: OLDOF_..._OPERATOR internally splits tokens into a 2-tuple. -#define BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_17_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_TYPE(traits)) \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_ASSIGN(traits) \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_OPERATOR \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_EXPR(traits) \ - , - -/* PUBLIC (18) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_18( \ - s, assertions, assertion_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_18_(s, assertions, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_18_, assertion_traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_18( \ - s, assertions, assertion_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_18_(s, assertions, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_18_, assertion_traits) - -/* PRIVATE (18) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_18_( \ - s, assertions, assertion_macro, assertion_traits) \ - ( \ - BOOST_PP_TUPLE_REM_CTOR(assertions) \ - assertion_macro(s, assertion_traits) \ - ) - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_18_(s, traits) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_NAMESPACE_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_18_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_USING_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_18_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_TYPEDEF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_18_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_18_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_18_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_18_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_18_ \ - ))))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_18_(s, traits) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_RETURN_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_18_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_18_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_18_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_18_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_18_ \ - ))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_18_(s, traits) \ - namespace \ - (BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NEW_NAME(traits)) \ - as BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NAME(traits) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_18_(s, traits) \ - BOOST_PP_EXPR_IIF( \ - BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS( \ - traits \ - ) \ - )) \ - , \ - template \ - ) \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS(traits) \ - using \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAMESPACE(traits) \ - BOOST_PP_EXPR_IIF(BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits))), \ - (BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits)) as \ - ) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAME(traits)) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_18_(s, traits) \ - typedef \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NAME(traits)) \ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NEW_NAME(traits) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_18_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_18_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_18_(s, traits, \ - has_trailing_comma) \ - const \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)), \ - () BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(BOOST_CONTRACT_TEST_AUX_PP_CAPTURE_S_, (), \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)) \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_EXPR(traits) \ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_18_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_18_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_18_(s, traits, \ - has_trailing_comma) \ - BOOST_CONTRACT_EXT_PP_BOOL_ASSERTION_TRAITS_EXPR(traits) \ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_18_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_18_(s, traits, 0, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_19) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_18_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_18_(s, traits, 0, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_19) - -#define BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_18_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_18_(s, traits, 1, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_19) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_18_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_18_(s, traits, 1, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_19) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_18_(s, traits, \ - is_static, next_assertion_macro) \ - BOOST_PP_EXPR_IIF(is_static, static) \ - if( \ - BOOST_PP_IIF( \ - BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND( \ - traits \ - ))) \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_19_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_19_ \ - )(s, BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND(traits), 0) \ - ) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)), \ - ( ) BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(next_assertion_macro, (), \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)) \ - else \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)), \ - ( ) BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(next_assertion_macro, (), \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)) - -// Extra parenthesis always internally added for if bool cond (so remove them). -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_18_(s, \ - cond_traits, has_trailing_comma) \ - BOOST_PP_TUPLE_REM_CTOR( BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_18_( \ - s, cond_traits, has_trailing_comma) ) - -#define BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_18_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_TYPE(traits)) \ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_ASSIGN(traits) \ - return \ - , - -// Implementation: OLDOF_..._OPERATOR internally splits tokens into a 2-tuple. -#define BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_18_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_TYPE(traits)) \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_ASSIGN(traits) \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_OPERATOR \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_EXPR(traits) \ - , - -/* PUBLIC (19) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_19( \ - s, assertions, assertion_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_19_(s, assertions, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_19_, assertion_traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_19( \ - s, assertions, assertion_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_19_(s, assertions, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_19_, assertion_traits) - -/* PRIVATE (19) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_19_( \ - s, assertions, assertion_macro, assertion_traits) \ - ( \ - BOOST_PP_TUPLE_REM_CTOR(assertions) \ - assertion_macro(s, assertion_traits) \ - ) - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_19_(s, traits) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_NAMESPACE_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_19_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_USING_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_19_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_TYPEDEF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_19_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_19_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_19_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_19_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_19_ \ - ))))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_19_(s, traits) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_RETURN_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_19_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_19_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_19_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_19_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_19_ \ - ))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_19_(s, traits) \ - namespace \ - (BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NEW_NAME(traits)) \ - as BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NAME(traits) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_19_(s, traits) \ - BOOST_PP_EXPR_IIF( \ - BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS( \ - traits \ - ) \ - )) \ - , \ - template \ - ) \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS(traits) \ - using \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAMESPACE(traits) \ - BOOST_PP_EXPR_IIF(BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits))), \ - (BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits)) as \ - ) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAME(traits)) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_19_(s, traits) \ - typedef \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NAME(traits)) \ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NEW_NAME(traits) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_19_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_19_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_19_(s, traits, \ - has_trailing_comma) \ - const \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)), \ - () BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(BOOST_CONTRACT_TEST_AUX_PP_CAPTURE_S_, (), \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)) \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_EXPR(traits) \ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_19_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_19_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_19_(s, traits, \ - has_trailing_comma) \ - BOOST_CONTRACT_EXT_PP_BOOL_ASSERTION_TRAITS_EXPR(traits) \ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_19_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_19_(s, traits, 0, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_20) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_19_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_19_(s, traits, 0, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_20) - -#define BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_19_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_19_(s, traits, 1, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_20) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_19_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_19_(s, traits, 1, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_20) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_19_(s, traits, \ - is_static, next_assertion_macro) \ - BOOST_PP_EXPR_IIF(is_static, static) \ - if( \ - BOOST_PP_IIF( \ - BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND( \ - traits \ - ))) \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_20_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_20_ \ - )(s, BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND(traits), 0) \ - ) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)), \ - ( ) BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(next_assertion_macro, (), \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)) \ - else \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)), \ - ( ) BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(next_assertion_macro, (), \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)) - -// Extra parenthesis always internally added for if bool cond (so remove them). -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_19_(s, \ - cond_traits, has_trailing_comma) \ - BOOST_PP_TUPLE_REM_CTOR( BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_19_( \ - s, cond_traits, has_trailing_comma) ) - -#define BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_19_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_TYPE(traits)) \ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_ASSIGN(traits) \ - return \ - , - -// Implementation: OLDOF_..._OPERATOR internally splits tokens into a 2-tuple. -#define BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_19_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_TYPE(traits)) \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_ASSIGN(traits) \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_OPERATOR \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_EXPR(traits) \ - , - -/* PUBLIC (20) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_20( \ - s, assertions, assertion_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_20_(s, assertions, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_20_, assertion_traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_20( \ - s, assertions, assertion_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_20_(s, assertions, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_20_, assertion_traits) - -/* PRIVATE (20) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_20_( \ - s, assertions, assertion_macro, assertion_traits) \ - ( \ - BOOST_PP_TUPLE_REM_CTOR(assertions) \ - assertion_macro(s, assertion_traits) \ - ) - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_20_(s, traits) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_NAMESPACE_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_20_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_USING_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_20_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_TYPEDEF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_20_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_20_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_20_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_20_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_20_ \ - ))))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_20_(s, traits) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_RETURN_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_20_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_20_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_20_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_20_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_20_ \ - ))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_20_(s, traits) \ - namespace \ - (BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NEW_NAME(traits)) \ - as BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NAME(traits) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_20_(s, traits) \ - BOOST_PP_EXPR_IIF( \ - BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS( \ - traits \ - ) \ - )) \ - , \ - template \ - ) \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS(traits) \ - using \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAMESPACE(traits) \ - BOOST_PP_EXPR_IIF(BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits))), \ - (BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits)) as \ - ) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAME(traits)) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_20_(s, traits) \ - typedef \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NAME(traits)) \ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NEW_NAME(traits) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_20_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_20_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_20_(s, traits, \ - has_trailing_comma) \ - const \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)), \ - () BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(BOOST_CONTRACT_TEST_AUX_PP_CAPTURE_S_, (), \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)) \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_EXPR(traits) \ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_20_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_20_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_20_(s, traits, \ - has_trailing_comma) \ - BOOST_CONTRACT_EXT_PP_BOOL_ASSERTION_TRAITS_EXPR(traits) \ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_20_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_20_(s, traits, 0, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_21) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_20_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_20_(s, traits, 0, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_21) - -#define BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_20_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_20_(s, traits, 1, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_21) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_20_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_20_(s, traits, 1, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_21) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_20_(s, traits, \ - is_static, next_assertion_macro) \ - BOOST_PP_EXPR_IIF(is_static, static) \ - if( \ - BOOST_PP_IIF( \ - BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND( \ - traits \ - ))) \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_21_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_21_ \ - )(s, BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND(traits), 0) \ - ) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)), \ - ( ) BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(next_assertion_macro, (), \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)) \ - else \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)), \ - ( ) BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(next_assertion_macro, (), \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)) - -// Extra parenthesis always internally added for if bool cond (so remove them). -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_20_(s, \ - cond_traits, has_trailing_comma) \ - BOOST_PP_TUPLE_REM_CTOR( BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_20_( \ - s, cond_traits, has_trailing_comma) ) - -#define BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_20_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_TYPE(traits)) \ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_ASSIGN(traits) \ - return \ - , - -// Implementation: OLDOF_..._OPERATOR internally splits tokens into a 2-tuple. -#define BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_20_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_TYPE(traits)) \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_ASSIGN(traits) \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_OPERATOR \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_EXPR(traits) \ - , - -/* PUBLIC (21) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_21( \ - s, assertions, assertion_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_21_(s, assertions, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_21_, assertion_traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_21( \ - s, assertions, assertion_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_21_(s, assertions, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_21_, assertion_traits) - -/* PRIVATE (21) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_21_( \ - s, assertions, assertion_macro, assertion_traits) \ - ( \ - BOOST_PP_TUPLE_REM_CTOR(assertions) \ - assertion_macro(s, assertion_traits) \ - ) - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_21_(s, traits) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_NAMESPACE_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_21_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_USING_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_21_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_TYPEDEF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_21_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_21_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_21_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_21_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_21_ \ - ))))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_21_(s, traits) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_RETURN_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_21_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_21_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_21_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_21_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_21_ \ - ))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_21_(s, traits) \ - namespace \ - (BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NEW_NAME(traits)) \ - as BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NAME(traits) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_21_(s, traits) \ - BOOST_PP_EXPR_IIF( \ - BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS( \ - traits \ - ) \ - )) \ - , \ - template \ - ) \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS(traits) \ - using \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAMESPACE(traits) \ - BOOST_PP_EXPR_IIF(BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits))), \ - (BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits)) as \ - ) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAME(traits)) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_21_(s, traits) \ - typedef \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NAME(traits)) \ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NEW_NAME(traits) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_21_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_21_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_21_(s, traits, \ - has_trailing_comma) \ - const \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)), \ - () BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(BOOST_CONTRACT_TEST_AUX_PP_CAPTURE_S_, (), \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)) \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_EXPR(traits) \ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_21_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_21_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_21_(s, traits, \ - has_trailing_comma) \ - BOOST_CONTRACT_EXT_PP_BOOL_ASSERTION_TRAITS_EXPR(traits) \ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_21_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_21_(s, traits, 0, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_22) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_21_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_21_(s, traits, 0, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_22) - -#define BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_21_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_21_(s, traits, 1, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_22) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_21_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_21_(s, traits, 1, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_22) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_21_(s, traits, \ - is_static, next_assertion_macro) \ - BOOST_PP_EXPR_IIF(is_static, static) \ - if( \ - BOOST_PP_IIF( \ - BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND( \ - traits \ - ))) \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_22_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_22_ \ - )(s, BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND(traits), 0) \ - ) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)), \ - ( ) BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(next_assertion_macro, (), \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)) \ - else \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)), \ - ( ) BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(next_assertion_macro, (), \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)) - -// Extra parenthesis always internally added for if bool cond (so remove them). -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_21_(s, \ - cond_traits, has_trailing_comma) \ - BOOST_PP_TUPLE_REM_CTOR( BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_21_( \ - s, cond_traits, has_trailing_comma) ) - -#define BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_21_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_TYPE(traits)) \ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_ASSIGN(traits) \ - return \ - , - -// Implementation: OLDOF_..._OPERATOR internally splits tokens into a 2-tuple. -#define BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_21_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_TYPE(traits)) \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_ASSIGN(traits) \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_OPERATOR \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_EXPR(traits) \ - , - -/* PUBLIC (22) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_22( \ - s, assertions, assertion_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_22_(s, assertions, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_22_, assertion_traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_22( \ - s, assertions, assertion_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_22_(s, assertions, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_22_, assertion_traits) - -/* PRIVATE (22) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_22_( \ - s, assertions, assertion_macro, assertion_traits) \ - ( \ - BOOST_PP_TUPLE_REM_CTOR(assertions) \ - assertion_macro(s, assertion_traits) \ - ) - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_22_(s, traits) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_NAMESPACE_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_22_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_USING_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_22_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_TYPEDEF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_22_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_22_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_22_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_22_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_22_ \ - ))))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_22_(s, traits) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_RETURN_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_22_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_22_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_22_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_22_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_22_ \ - ))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_22_(s, traits) \ - namespace \ - (BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NEW_NAME(traits)) \ - as BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NAME(traits) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_22_(s, traits) \ - BOOST_PP_EXPR_IIF( \ - BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS( \ - traits \ - ) \ - )) \ - , \ - template \ - ) \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS(traits) \ - using \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAMESPACE(traits) \ - BOOST_PP_EXPR_IIF(BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits))), \ - (BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits)) as \ - ) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAME(traits)) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_22_(s, traits) \ - typedef \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NAME(traits)) \ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NEW_NAME(traits) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_22_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_22_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_22_(s, traits, \ - has_trailing_comma) \ - const \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)), \ - () BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(BOOST_CONTRACT_TEST_AUX_PP_CAPTURE_S_, (), \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)) \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_EXPR(traits) \ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_22_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_22_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_22_(s, traits, \ - has_trailing_comma) \ - BOOST_CONTRACT_EXT_PP_BOOL_ASSERTION_TRAITS_EXPR(traits) \ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_22_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_22_(s, traits, 0, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_23) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_22_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_22_(s, traits, 0, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_23) - -#define BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_22_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_22_(s, traits, 1, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_23) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_22_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_22_(s, traits, 1, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_23) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_22_(s, traits, \ - is_static, next_assertion_macro) \ - BOOST_PP_EXPR_IIF(is_static, static) \ - if( \ - BOOST_PP_IIF( \ - BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND( \ - traits \ - ))) \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_23_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_23_ \ - )(s, BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND(traits), 0) \ - ) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)), \ - ( ) BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(next_assertion_macro, (), \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)) \ - else \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)), \ - ( ) BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(next_assertion_macro, (), \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)) - -// Extra parenthesis always internally added for if bool cond (so remove them). -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_22_(s, \ - cond_traits, has_trailing_comma) \ - BOOST_PP_TUPLE_REM_CTOR( BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_22_( \ - s, cond_traits, has_trailing_comma) ) - -#define BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_22_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_TYPE(traits)) \ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_ASSIGN(traits) \ - return \ - , - -// Implementation: OLDOF_..._OPERATOR internally splits tokens into a 2-tuple. -#define BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_22_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_TYPE(traits)) \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_ASSIGN(traits) \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_OPERATOR \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_EXPR(traits) \ - , - -/* PUBLIC (23) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_23( \ - s, assertions, assertion_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_23_(s, assertions, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_23_, assertion_traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_23( \ - s, assertions, assertion_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_23_(s, assertions, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_23_, assertion_traits) - -/* PRIVATE (23) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_23_( \ - s, assertions, assertion_macro, assertion_traits) \ - ( \ - BOOST_PP_TUPLE_REM_CTOR(assertions) \ - assertion_macro(s, assertion_traits) \ - ) - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_23_(s, traits) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_NAMESPACE_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_23_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_USING_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_23_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_TYPEDEF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_23_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_23_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_23_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_23_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_23_ \ - ))))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_23_(s, traits) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_RETURN_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_23_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_23_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_23_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_23_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_23_ \ - ))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_23_(s, traits) \ - namespace \ - (BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NEW_NAME(traits)) \ - as BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NAME(traits) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_23_(s, traits) \ - BOOST_PP_EXPR_IIF( \ - BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS( \ - traits \ - ) \ - )) \ - , \ - template \ - ) \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS(traits) \ - using \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAMESPACE(traits) \ - BOOST_PP_EXPR_IIF(BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits))), \ - (BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits)) as \ - ) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAME(traits)) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_23_(s, traits) \ - typedef \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NAME(traits)) \ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NEW_NAME(traits) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_23_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_23_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_23_(s, traits, \ - has_trailing_comma) \ - const \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)), \ - () BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(BOOST_CONTRACT_TEST_AUX_PP_CAPTURE_S_, (), \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)) \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_EXPR(traits) \ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_23_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_23_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_23_(s, traits, \ - has_trailing_comma) \ - BOOST_CONTRACT_EXT_PP_BOOL_ASSERTION_TRAITS_EXPR(traits) \ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_23_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_23_(s, traits, 0, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_24) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_23_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_23_(s, traits, 0, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_24) - -#define BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_23_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_23_(s, traits, 1, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_24) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_23_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_23_(s, traits, 1, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_24) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_23_(s, traits, \ - is_static, next_assertion_macro) \ - BOOST_PP_EXPR_IIF(is_static, static) \ - if( \ - BOOST_PP_IIF( \ - BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND( \ - traits \ - ))) \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_24_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_24_ \ - )(s, BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND(traits), 0) \ - ) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)), \ - ( ) BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(next_assertion_macro, (), \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)) \ - else \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)), \ - ( ) BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(next_assertion_macro, (), \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)) - -// Extra parenthesis always internally added for if bool cond (so remove them). -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_23_(s, \ - cond_traits, has_trailing_comma) \ - BOOST_PP_TUPLE_REM_CTOR( BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_23_( \ - s, cond_traits, has_trailing_comma) ) - -#define BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_23_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_TYPE(traits)) \ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_ASSIGN(traits) \ - return \ - , - -// Implementation: OLDOF_..._OPERATOR internally splits tokens into a 2-tuple. -#define BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_23_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_TYPE(traits)) \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_ASSIGN(traits) \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_OPERATOR \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_EXPR(traits) \ - , - -/* PUBLIC (24) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_24( \ - s, assertions, assertion_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_24_(s, assertions, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_24_, assertion_traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_24( \ - s, assertions, assertion_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_24_(s, assertions, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_24_, assertion_traits) - -/* PRIVATE (24) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_24_( \ - s, assertions, assertion_macro, assertion_traits) \ - ( \ - BOOST_PP_TUPLE_REM_CTOR(assertions) \ - assertion_macro(s, assertion_traits) \ - ) - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_24_(s, traits) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_NAMESPACE_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_24_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_USING_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_24_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_TYPEDEF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_24_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_24_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_24_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_24_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_24_ \ - ))))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_24_(s, traits) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_RETURN_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_24_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_24_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_24_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_24_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_24_ \ - ))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_24_(s, traits) \ - namespace \ - (BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NEW_NAME(traits)) \ - as BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NAME(traits) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_24_(s, traits) \ - BOOST_PP_EXPR_IIF( \ - BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS( \ - traits \ - ) \ - )) \ - , \ - template \ - ) \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS(traits) \ - using \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAMESPACE(traits) \ - BOOST_PP_EXPR_IIF(BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits))), \ - (BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits)) as \ - ) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAME(traits)) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_24_(s, traits) \ - typedef \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NAME(traits)) \ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NEW_NAME(traits) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_24_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_24_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_24_(s, traits, \ - has_trailing_comma) \ - const \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)), \ - () BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(BOOST_CONTRACT_TEST_AUX_PP_CAPTURE_S_, (), \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)) \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_EXPR(traits) \ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_24_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_24_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_24_(s, traits, \ - has_trailing_comma) \ - BOOST_CONTRACT_EXT_PP_BOOL_ASSERTION_TRAITS_EXPR(traits) \ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_24_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_24_(s, traits, 0, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_25) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_24_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_24_(s, traits, 0, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_25) - -#define BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_24_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_24_(s, traits, 1, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_25) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_24_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_24_(s, traits, 1, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_25) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_24_(s, traits, \ - is_static, next_assertion_macro) \ - BOOST_PP_EXPR_IIF(is_static, static) \ - if( \ - BOOST_PP_IIF( \ - BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND( \ - traits \ - ))) \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_25_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_25_ \ - )(s, BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND(traits), 0) \ - ) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)), \ - ( ) BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(next_assertion_macro, (), \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)) \ - else \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)), \ - ( ) BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(next_assertion_macro, (), \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)) - -// Extra parenthesis always internally added for if bool cond (so remove them). -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_24_(s, \ - cond_traits, has_trailing_comma) \ - BOOST_PP_TUPLE_REM_CTOR( BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_24_( \ - s, cond_traits, has_trailing_comma) ) - -#define BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_24_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_TYPE(traits)) \ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_ASSIGN(traits) \ - return \ - , - -// Implementation: OLDOF_..._OPERATOR internally splits tokens into a 2-tuple. -#define BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_24_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_TYPE(traits)) \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_ASSIGN(traits) \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_OPERATOR \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_EXPR(traits) \ - , - -/* PUBLIC (25) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_25( \ - s, assertions, assertion_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_25_(s, assertions, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_25_, assertion_traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_25( \ - s, assertions, assertion_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_25_(s, assertions, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_25_, assertion_traits) - -/* PRIVATE (25) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_25_( \ - s, assertions, assertion_macro, assertion_traits) \ - ( \ - BOOST_PP_TUPLE_REM_CTOR(assertions) \ - assertion_macro(s, assertion_traits) \ - ) - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_25_(s, traits) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_NAMESPACE_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_25_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_USING_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_25_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_TYPEDEF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_25_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_25_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_25_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_25_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_25_ \ - ))))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_25_(s, traits) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_RETURN_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_25_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_25_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_25_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_25_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_25_ \ - ))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_25_(s, traits) \ - namespace \ - (BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NEW_NAME(traits)) \ - as BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NAME(traits) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_25_(s, traits) \ - BOOST_PP_EXPR_IIF( \ - BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS( \ - traits \ - ) \ - )) \ - , \ - template \ - ) \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS(traits) \ - using \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAMESPACE(traits) \ - BOOST_PP_EXPR_IIF(BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits))), \ - (BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits)) as \ - ) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAME(traits)) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_25_(s, traits) \ - typedef \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NAME(traits)) \ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NEW_NAME(traits) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_25_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_25_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_25_(s, traits, \ - has_trailing_comma) \ - const \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)), \ - () BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(BOOST_CONTRACT_TEST_AUX_PP_CAPTURE_S_, (), \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)) \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_EXPR(traits) \ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_25_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_25_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_25_(s, traits, \ - has_trailing_comma) \ - BOOST_CONTRACT_EXT_PP_BOOL_ASSERTION_TRAITS_EXPR(traits) \ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_25_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_25_(s, traits, 0, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_26) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_25_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_25_(s, traits, 0, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_26) - -#define BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_25_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_25_(s, traits, 1, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_26) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_25_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_25_(s, traits, 1, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_26) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_25_(s, traits, \ - is_static, next_assertion_macro) \ - BOOST_PP_EXPR_IIF(is_static, static) \ - if( \ - BOOST_PP_IIF( \ - BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND( \ - traits \ - ))) \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_26_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_26_ \ - )(s, BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND(traits), 0) \ - ) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)), \ - ( ) BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(next_assertion_macro, (), \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)) \ - else \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)), \ - ( ) BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(next_assertion_macro, (), \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)) - -// Extra parenthesis always internally added for if bool cond (so remove them). -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_25_(s, \ - cond_traits, has_trailing_comma) \ - BOOST_PP_TUPLE_REM_CTOR( BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_25_( \ - s, cond_traits, has_trailing_comma) ) - -#define BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_25_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_TYPE(traits)) \ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_ASSIGN(traits) \ - return \ - , - -// Implementation: OLDOF_..._OPERATOR internally splits tokens into a 2-tuple. -#define BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_25_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_TYPE(traits)) \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_ASSIGN(traits) \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_OPERATOR \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_EXPR(traits) \ - , - -/* PUBLIC (26) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_26( \ - s, assertions, assertion_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_26_(s, assertions, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_26_, assertion_traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_26( \ - s, assertions, assertion_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_26_(s, assertions, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_26_, assertion_traits) - -/* PRIVATE (26) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_26_( \ - s, assertions, assertion_macro, assertion_traits) \ - ( \ - BOOST_PP_TUPLE_REM_CTOR(assertions) \ - assertion_macro(s, assertion_traits) \ - ) - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_26_(s, traits) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_NAMESPACE_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_26_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_USING_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_26_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_TYPEDEF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_26_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_26_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_26_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_26_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_26_ \ - ))))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_26_(s, traits) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_RETURN_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_26_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_26_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_26_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_26_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_26_ \ - ))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_26_(s, traits) \ - namespace \ - (BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NEW_NAME(traits)) \ - as BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NAME(traits) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_26_(s, traits) \ - BOOST_PP_EXPR_IIF( \ - BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS( \ - traits \ - ) \ - )) \ - , \ - template \ - ) \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS(traits) \ - using \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAMESPACE(traits) \ - BOOST_PP_EXPR_IIF(BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits))), \ - (BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits)) as \ - ) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAME(traits)) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_26_(s, traits) \ - typedef \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NAME(traits)) \ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NEW_NAME(traits) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_26_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_26_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_26_(s, traits, \ - has_trailing_comma) \ - const \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)), \ - () BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(BOOST_CONTRACT_TEST_AUX_PP_CAPTURE_S_, (), \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)) \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_EXPR(traits) \ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_26_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_26_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_26_(s, traits, \ - has_trailing_comma) \ - BOOST_CONTRACT_EXT_PP_BOOL_ASSERTION_TRAITS_EXPR(traits) \ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_26_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_26_(s, traits, 0, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_27) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_26_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_26_(s, traits, 0, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_27) - -#define BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_26_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_26_(s, traits, 1, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_27) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_26_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_26_(s, traits, 1, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_27) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_26_(s, traits, \ - is_static, next_assertion_macro) \ - BOOST_PP_EXPR_IIF(is_static, static) \ - if( \ - BOOST_PP_IIF( \ - BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND( \ - traits \ - ))) \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_27_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_27_ \ - )(s, BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND(traits), 0) \ - ) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)), \ - ( ) BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(next_assertion_macro, (), \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)) \ - else \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)), \ - ( ) BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(next_assertion_macro, (), \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)) - -// Extra parenthesis always internally added for if bool cond (so remove them). -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_26_(s, \ - cond_traits, has_trailing_comma) \ - BOOST_PP_TUPLE_REM_CTOR( BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_26_( \ - s, cond_traits, has_trailing_comma) ) - -#define BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_26_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_TYPE(traits)) \ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_ASSIGN(traits) \ - return \ - , - -// Implementation: OLDOF_..._OPERATOR internally splits tokens into a 2-tuple. -#define BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_26_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_TYPE(traits)) \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_ASSIGN(traits) \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_OPERATOR \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_EXPR(traits) \ - , - -/* PUBLIC (27) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_27( \ - s, assertions, assertion_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_27_(s, assertions, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_27_, assertion_traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_27( \ - s, assertions, assertion_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_27_(s, assertions, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_27_, assertion_traits) - -/* PRIVATE (27) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_27_( \ - s, assertions, assertion_macro, assertion_traits) \ - ( \ - BOOST_PP_TUPLE_REM_CTOR(assertions) \ - assertion_macro(s, assertion_traits) \ - ) - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_27_(s, traits) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_NAMESPACE_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_27_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_USING_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_27_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_TYPEDEF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_27_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_27_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_27_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_27_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_27_ \ - ))))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_27_(s, traits) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_RETURN_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_27_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_27_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_27_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_27_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_27_ \ - ))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_27_(s, traits) \ - namespace \ - (BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NEW_NAME(traits)) \ - as BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NAME(traits) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_27_(s, traits) \ - BOOST_PP_EXPR_IIF( \ - BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS( \ - traits \ - ) \ - )) \ - , \ - template \ - ) \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS(traits) \ - using \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAMESPACE(traits) \ - BOOST_PP_EXPR_IIF(BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits))), \ - (BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits)) as \ - ) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAME(traits)) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_27_(s, traits) \ - typedef \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NAME(traits)) \ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NEW_NAME(traits) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_27_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_27_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_27_(s, traits, \ - has_trailing_comma) \ - const \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)), \ - () BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(BOOST_CONTRACT_TEST_AUX_PP_CAPTURE_S_, (), \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)) \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_EXPR(traits) \ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_27_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_27_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_27_(s, traits, \ - has_trailing_comma) \ - BOOST_CONTRACT_EXT_PP_BOOL_ASSERTION_TRAITS_EXPR(traits) \ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_27_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_27_(s, traits, 0, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_28) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_27_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_27_(s, traits, 0, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_28) - -#define BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_27_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_27_(s, traits, 1, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_28) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_27_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_27_(s, traits, 1, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_28) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_27_(s, traits, \ - is_static, next_assertion_macro) \ - BOOST_PP_EXPR_IIF(is_static, static) \ - if( \ - BOOST_PP_IIF( \ - BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND( \ - traits \ - ))) \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_28_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_28_ \ - )(s, BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND(traits), 0) \ - ) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)), \ - ( ) BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(next_assertion_macro, (), \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)) \ - else \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)), \ - ( ) BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(next_assertion_macro, (), \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)) - -// Extra parenthesis always internally added for if bool cond (so remove them). -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_27_(s, \ - cond_traits, has_trailing_comma) \ - BOOST_PP_TUPLE_REM_CTOR( BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_27_( \ - s, cond_traits, has_trailing_comma) ) - -#define BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_27_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_TYPE(traits)) \ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_ASSIGN(traits) \ - return \ - , - -// Implementation: OLDOF_..._OPERATOR internally splits tokens into a 2-tuple. -#define BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_27_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_TYPE(traits)) \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_ASSIGN(traits) \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_OPERATOR \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_EXPR(traits) \ - , - -/* PUBLIC (28) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_28( \ - s, assertions, assertion_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_28_(s, assertions, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_28_, assertion_traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_28( \ - s, assertions, assertion_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_28_(s, assertions, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_28_, assertion_traits) - -/* PRIVATE (28) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_28_( \ - s, assertions, assertion_macro, assertion_traits) \ - ( \ - BOOST_PP_TUPLE_REM_CTOR(assertions) \ - assertion_macro(s, assertion_traits) \ - ) - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_28_(s, traits) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_NAMESPACE_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_28_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_USING_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_28_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_TYPEDEF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_28_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_28_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_28_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_28_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_28_ \ - ))))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_28_(s, traits) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_RETURN_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_28_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_28_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_28_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_28_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_28_ \ - ))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_28_(s, traits) \ - namespace \ - (BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NEW_NAME(traits)) \ - as BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NAME(traits) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_28_(s, traits) \ - BOOST_PP_EXPR_IIF( \ - BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS( \ - traits \ - ) \ - )) \ - , \ - template \ - ) \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS(traits) \ - using \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAMESPACE(traits) \ - BOOST_PP_EXPR_IIF(BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits))), \ - (BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits)) as \ - ) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAME(traits)) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_28_(s, traits) \ - typedef \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NAME(traits)) \ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NEW_NAME(traits) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_28_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_28_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_28_(s, traits, \ - has_trailing_comma) \ - const \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)), \ - () BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(BOOST_CONTRACT_TEST_AUX_PP_CAPTURE_S_, (), \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)) \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_EXPR(traits) \ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_28_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_28_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_28_(s, traits, \ - has_trailing_comma) \ - BOOST_CONTRACT_EXT_PP_BOOL_ASSERTION_TRAITS_EXPR(traits) \ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_28_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_28_(s, traits, 0, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_29) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_28_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_28_(s, traits, 0, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_29) - -#define BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_28_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_28_(s, traits, 1, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_29) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_28_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_28_(s, traits, 1, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_29) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_28_(s, traits, \ - is_static, next_assertion_macro) \ - BOOST_PP_EXPR_IIF(is_static, static) \ - if( \ - BOOST_PP_IIF( \ - BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND( \ - traits \ - ))) \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_29_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_29_ \ - )(s, BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND(traits), 0) \ - ) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)), \ - ( ) BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(next_assertion_macro, (), \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)) \ - else \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)), \ - ( ) BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(next_assertion_macro, (), \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)) - -// Extra parenthesis always internally added for if bool cond (so remove them). -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_28_(s, \ - cond_traits, has_trailing_comma) \ - BOOST_PP_TUPLE_REM_CTOR( BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_28_( \ - s, cond_traits, has_trailing_comma) ) - -#define BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_28_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_TYPE(traits)) \ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_ASSIGN(traits) \ - return \ - , - -// Implementation: OLDOF_..._OPERATOR internally splits tokens into a 2-tuple. -#define BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_28_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_TYPE(traits)) \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_ASSIGN(traits) \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_OPERATOR \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_EXPR(traits) \ - , - -/* PUBLIC (29) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_29( \ - s, assertions, assertion_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_29_(s, assertions, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_29_, assertion_traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_29( \ - s, assertions, assertion_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_29_(s, assertions, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_29_, assertion_traits) - -/* PRIVATE (29) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_29_( \ - s, assertions, assertion_macro, assertion_traits) \ - ( \ - BOOST_PP_TUPLE_REM_CTOR(assertions) \ - assertion_macro(s, assertion_traits) \ - ) - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_29_(s, traits) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_NAMESPACE_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_29_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_USING_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_29_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_TYPEDEF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_29_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_29_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_29_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_29_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_29_ \ - ))))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_29_(s, traits) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_RETURN_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_29_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_29_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_29_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_29_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_29_ \ - ))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_29_(s, traits) \ - namespace \ - (BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NEW_NAME(traits)) \ - as BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NAME(traits) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_29_(s, traits) \ - BOOST_PP_EXPR_IIF( \ - BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS( \ - traits \ - ) \ - )) \ - , \ - template \ - ) \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS(traits) \ - using \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAMESPACE(traits) \ - BOOST_PP_EXPR_IIF(BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits))), \ - (BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits)) as \ - ) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAME(traits)) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_29_(s, traits) \ - typedef \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NAME(traits)) \ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NEW_NAME(traits) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_29_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_29_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_29_(s, traits, \ - has_trailing_comma) \ - const \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)), \ - () BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(BOOST_CONTRACT_TEST_AUX_PP_CAPTURE_S_, (), \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)) \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_EXPR(traits) \ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_29_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_29_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_29_(s, traits, \ - has_trailing_comma) \ - BOOST_CONTRACT_EXT_PP_BOOL_ASSERTION_TRAITS_EXPR(traits) \ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_29_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_29_(s, traits, 0, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_30) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_29_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_29_(s, traits, 0, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_30) - -#define BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_29_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_29_(s, traits, 1, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_30) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_29_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_29_(s, traits, 1, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_30) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_29_(s, traits, \ - is_static, next_assertion_macro) \ - BOOST_PP_EXPR_IIF(is_static, static) \ - if( \ - BOOST_PP_IIF( \ - BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND( \ - traits \ - ))) \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_30_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_30_ \ - )(s, BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND(traits), 0) \ - ) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)), \ - ( ) BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(next_assertion_macro, (), \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)) \ - else \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)), \ - ( ) BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(next_assertion_macro, (), \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)) - -// Extra parenthesis always internally added for if bool cond (so remove them). -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_29_(s, \ - cond_traits, has_trailing_comma) \ - BOOST_PP_TUPLE_REM_CTOR( BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_29_( \ - s, cond_traits, has_trailing_comma) ) - -#define BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_29_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_TYPE(traits)) \ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_ASSIGN(traits) \ - return \ - , - -// Implementation: OLDOF_..._OPERATOR internally splits tokens into a 2-tuple. -#define BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_29_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_TYPE(traits)) \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_ASSIGN(traits) \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_OPERATOR \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_EXPR(traits) \ - , - -/* PUBLIC (30) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_30( \ - s, assertions, assertion_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_30_(s, assertions, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_30_, assertion_traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_30( \ - s, assertions, assertion_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_30_(s, assertions, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_30_, assertion_traits) - -/* PRIVATE (30) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_30_( \ - s, assertions, assertion_macro, assertion_traits) \ - ( \ - BOOST_PP_TUPLE_REM_CTOR(assertions) \ - assertion_macro(s, assertion_traits) \ - ) - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_30_(s, traits) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_NAMESPACE_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_30_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_USING_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_30_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_TYPEDEF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_30_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_30_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_30_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_30_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_30_ \ - ))))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_30_(s, traits) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_RETURN_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_30_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_30_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_30_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_30_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_30_ \ - ))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_30_(s, traits) \ - namespace \ - (BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NEW_NAME(traits)) \ - as BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NAME(traits) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_30_(s, traits) \ - BOOST_PP_EXPR_IIF( \ - BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS( \ - traits \ - ) \ - )) \ - , \ - template \ - ) \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS(traits) \ - using \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAMESPACE(traits) \ - BOOST_PP_EXPR_IIF(BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits))), \ - (BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits)) as \ - ) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAME(traits)) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_30_(s, traits) \ - typedef \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NAME(traits)) \ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NEW_NAME(traits) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_30_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_30_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_30_(s, traits, \ - has_trailing_comma) \ - const \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)), \ - () BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(BOOST_CONTRACT_TEST_AUX_PP_CAPTURE_S_, (), \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)) \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_EXPR(traits) \ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_30_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_30_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_30_(s, traits, \ - has_trailing_comma) \ - BOOST_CONTRACT_EXT_PP_BOOL_ASSERTION_TRAITS_EXPR(traits) \ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_30_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_30_(s, traits, 0, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_31) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_30_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_30_(s, traits, 0, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_31) - -#define BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_30_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_30_(s, traits, 1, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_31) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_30_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_30_(s, traits, 1, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_31) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_30_(s, traits, \ - is_static, next_assertion_macro) \ - BOOST_PP_EXPR_IIF(is_static, static) \ - if( \ - BOOST_PP_IIF( \ - BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND( \ - traits \ - ))) \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_31_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_31_ \ - )(s, BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND(traits), 0) \ - ) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)), \ - ( ) BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(next_assertion_macro, (), \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)) \ - else \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)), \ - ( ) BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(next_assertion_macro, (), \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)) - -// Extra parenthesis always internally added for if bool cond (so remove them). -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_30_(s, \ - cond_traits, has_trailing_comma) \ - BOOST_PP_TUPLE_REM_CTOR( BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_30_( \ - s, cond_traits, has_trailing_comma) ) - -#define BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_30_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_TYPE(traits)) \ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_ASSIGN(traits) \ - return \ - , - -// Implementation: OLDOF_..._OPERATOR internally splits tokens into a 2-tuple. -#define BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_30_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_TYPE(traits)) \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_ASSIGN(traits) \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_OPERATOR \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_EXPR(traits) \ - , - -/* PUBLIC (31) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_31( \ - s, assertions, assertion_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_31_(s, assertions, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_31_, assertion_traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_31( \ - s, assertions, assertion_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_31_(s, assertions, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_31_, assertion_traits) - -/* PRIVATE (31) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_31_( \ - s, assertions, assertion_macro, assertion_traits) \ - ( \ - BOOST_PP_TUPLE_REM_CTOR(assertions) \ - assertion_macro(s, assertion_traits) \ - ) - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_31_(s, traits) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_NAMESPACE_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_31_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_USING_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_31_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_TYPEDEF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_31_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_31_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_31_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_31_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_31_ \ - ))))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_31_(s, traits) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_RETURN_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_31_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_31_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_31_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_31_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_31_ \ - ))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_31_(s, traits) \ - namespace \ - (BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NEW_NAME(traits)) \ - as BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NAME(traits) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_31_(s, traits) \ - BOOST_PP_EXPR_IIF( \ - BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS( \ - traits \ - ) \ - )) \ - , \ - template \ - ) \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS(traits) \ - using \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAMESPACE(traits) \ - BOOST_PP_EXPR_IIF(BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits))), \ - (BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits)) as \ - ) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAME(traits)) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_31_(s, traits) \ - typedef \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NAME(traits)) \ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NEW_NAME(traits) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_31_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_31_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_31_(s, traits, \ - has_trailing_comma) \ - const \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)), \ - () BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(BOOST_CONTRACT_TEST_AUX_PP_CAPTURE_S_, (), \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)) \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_EXPR(traits) \ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_31_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_31_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_31_(s, traits, \ - has_trailing_comma) \ - BOOST_CONTRACT_EXT_PP_BOOL_ASSERTION_TRAITS_EXPR(traits) \ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_31_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_31_(s, traits, 0, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_32) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_31_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_31_(s, traits, 0, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_32) - -#define BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_31_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_31_(s, traits, 1, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_32) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_31_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_31_(s, traits, 1, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_32) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_31_(s, traits, \ - is_static, next_assertion_macro) \ - BOOST_PP_EXPR_IIF(is_static, static) \ - if( \ - BOOST_PP_IIF( \ - BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND( \ - traits \ - ))) \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_32_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_32_ \ - )(s, BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND(traits), 0) \ - ) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)), \ - ( ) BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(next_assertion_macro, (), \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)) \ - else \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)), \ - ( ) BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(next_assertion_macro, (), \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)) - -// Extra parenthesis always internally added for if bool cond (so remove them). -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_31_(s, \ - cond_traits, has_trailing_comma) \ - BOOST_PP_TUPLE_REM_CTOR( BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_31_( \ - s, cond_traits, has_trailing_comma) ) - -#define BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_31_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_TYPE(traits)) \ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_ASSIGN(traits) \ - return \ - , - -// Implementation: OLDOF_..._OPERATOR internally splits tokens into a 2-tuple. -#define BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_31_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_TYPE(traits)) \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_ASSIGN(traits) \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_OPERATOR \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_EXPR(traits) \ - , - -/* PUBLIC (32) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_32( \ - s, assertions, assertion_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_32_(s, assertions, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_32_, assertion_traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_32( \ - s, assertions, assertion_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_32_(s, assertions, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_32_, assertion_traits) - -/* PRIVATE (32) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_32_( \ - s, assertions, assertion_macro, assertion_traits) \ - ( \ - BOOST_PP_TUPLE_REM_CTOR(assertions) \ - assertion_macro(s, assertion_traits) \ - ) - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_32_(s, traits) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_NAMESPACE_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_32_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_USING_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_32_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_TYPEDEF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_32_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_32_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_32_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_32_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_32_ \ - ))))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_32_(s, traits) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_RETURN_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_32_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_32_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_32_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_32_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_32_ \ - ))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_32_(s, traits) \ - namespace \ - (BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NEW_NAME(traits)) \ - as BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NAME(traits) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_32_(s, traits) \ - BOOST_PP_EXPR_IIF( \ - BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS( \ - traits \ - ) \ - )) \ - , \ - template \ - ) \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS(traits) \ - using \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAMESPACE(traits) \ - BOOST_PP_EXPR_IIF(BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits))), \ - (BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits)) as \ - ) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAME(traits)) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_32_(s, traits) \ - typedef \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NAME(traits)) \ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NEW_NAME(traits) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_32_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_32_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_32_(s, traits, \ - has_trailing_comma) \ - const \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)), \ - () BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(BOOST_CONTRACT_TEST_AUX_PP_CAPTURE_S_, (), \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)) \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_EXPR(traits) \ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_32_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_32_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_32_(s, traits, \ - has_trailing_comma) \ - BOOST_CONTRACT_EXT_PP_BOOL_ASSERTION_TRAITS_EXPR(traits) \ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_32_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_32_(s, traits, 0, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_33) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_32_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_32_(s, traits, 0, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_33) - -#define BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_32_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_32_(s, traits, 1, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_33) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_32_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_32_(s, traits, 1, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_33) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_32_(s, traits, \ - is_static, next_assertion_macro) \ - BOOST_PP_EXPR_IIF(is_static, static) \ - if( \ - BOOST_PP_IIF( \ - BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND( \ - traits \ - ))) \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_33_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_33_ \ - )(s, BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND(traits), 0) \ - ) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)), \ - ( ) BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(next_assertion_macro, (), \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)) \ - else \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)), \ - ( ) BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(next_assertion_macro, (), \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)) - -// Extra parenthesis always internally added for if bool cond (so remove them). -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_32_(s, \ - cond_traits, has_trailing_comma) \ - BOOST_PP_TUPLE_REM_CTOR( BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_32_( \ - s, cond_traits, has_trailing_comma) ) - -#define BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_32_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_TYPE(traits)) \ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_ASSIGN(traits) \ - return \ - , - -// Implementation: OLDOF_..._OPERATOR internally splits tokens into a 2-tuple. -#define BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_32_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_TYPE(traits)) \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_ASSIGN(traits) \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_OPERATOR \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_EXPR(traits) \ - , - -/* PUBLIC (33) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_33( \ - s, assertions, assertion_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_33_(s, assertions, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_33_, assertion_traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_33( \ - s, assertions, assertion_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_33_(s, assertions, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_33_, assertion_traits) - -/* PRIVATE (33) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_33_( \ - s, assertions, assertion_macro, assertion_traits) \ - ( \ - BOOST_PP_TUPLE_REM_CTOR(assertions) \ - assertion_macro(s, assertion_traits) \ - ) - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_33_(s, traits) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_NAMESPACE_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_33_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_USING_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_33_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_TYPEDEF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_33_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_33_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_33_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_33_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_33_ \ - ))))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_33_(s, traits) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_RETURN_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_33_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_33_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_33_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_33_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_33_ \ - ))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_33_(s, traits) \ - namespace \ - (BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NEW_NAME(traits)) \ - as BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NAME(traits) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_33_(s, traits) \ - BOOST_PP_EXPR_IIF( \ - BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS( \ - traits \ - ) \ - )) \ - , \ - template \ - ) \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS(traits) \ - using \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAMESPACE(traits) \ - BOOST_PP_EXPR_IIF(BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits))), \ - (BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits)) as \ - ) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAME(traits)) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_33_(s, traits) \ - typedef \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NAME(traits)) \ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NEW_NAME(traits) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_33_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_33_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_33_(s, traits, \ - has_trailing_comma) \ - const \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)), \ - () BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(BOOST_CONTRACT_TEST_AUX_PP_CAPTURE_S_, (), \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)) \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_EXPR(traits) \ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_33_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_33_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_33_(s, traits, \ - has_trailing_comma) \ - BOOST_CONTRACT_EXT_PP_BOOL_ASSERTION_TRAITS_EXPR(traits) \ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_33_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_33_(s, traits, 0, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_34) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_33_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_33_(s, traits, 0, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_34) - -#define BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_33_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_33_(s, traits, 1, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_34) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_33_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_33_(s, traits, 1, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_34) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_33_(s, traits, \ - is_static, next_assertion_macro) \ - BOOST_PP_EXPR_IIF(is_static, static) \ - if( \ - BOOST_PP_IIF( \ - BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND( \ - traits \ - ))) \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_34_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_34_ \ - )(s, BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND(traits), 0) \ - ) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)), \ - ( ) BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(next_assertion_macro, (), \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)) \ - else \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)), \ - ( ) BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(next_assertion_macro, (), \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)) - -// Extra parenthesis always internally added for if bool cond (so remove them). -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_33_(s, \ - cond_traits, has_trailing_comma) \ - BOOST_PP_TUPLE_REM_CTOR( BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_33_( \ - s, cond_traits, has_trailing_comma) ) - -#define BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_33_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_TYPE(traits)) \ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_ASSIGN(traits) \ - return \ - , - -// Implementation: OLDOF_..._OPERATOR internally splits tokens into a 2-tuple. -#define BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_33_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_TYPE(traits)) \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_ASSIGN(traits) \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_OPERATOR \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_EXPR(traits) \ - , - -/* PUBLIC (34) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_34( \ - s, assertions, assertion_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_34_(s, assertions, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_34_, assertion_traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_34( \ - s, assertions, assertion_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_34_(s, assertions, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_34_, assertion_traits) - -/* PRIVATE (34) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_34_( \ - s, assertions, assertion_macro, assertion_traits) \ - ( \ - BOOST_PP_TUPLE_REM_CTOR(assertions) \ - assertion_macro(s, assertion_traits) \ - ) - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_34_(s, traits) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_NAMESPACE_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_34_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_USING_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_34_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_TYPEDEF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_34_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_34_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_34_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_34_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_34_ \ - ))))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_34_(s, traits) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_RETURN_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_34_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_34_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_34_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_34_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_34_ \ - ))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_34_(s, traits) \ - namespace \ - (BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NEW_NAME(traits)) \ - as BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NAME(traits) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_34_(s, traits) \ - BOOST_PP_EXPR_IIF( \ - BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS( \ - traits \ - ) \ - )) \ - , \ - template \ - ) \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS(traits) \ - using \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAMESPACE(traits) \ - BOOST_PP_EXPR_IIF(BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits))), \ - (BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits)) as \ - ) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAME(traits)) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_34_(s, traits) \ - typedef \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NAME(traits)) \ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NEW_NAME(traits) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_34_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_34_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_34_(s, traits, \ - has_trailing_comma) \ - const \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)), \ - () BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(BOOST_CONTRACT_TEST_AUX_PP_CAPTURE_S_, (), \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)) \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_EXPR(traits) \ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_34_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_34_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_34_(s, traits, \ - has_trailing_comma) \ - BOOST_CONTRACT_EXT_PP_BOOL_ASSERTION_TRAITS_EXPR(traits) \ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_34_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_34_(s, traits, 0, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_35) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_34_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_34_(s, traits, 0, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_35) - -#define BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_34_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_34_(s, traits, 1, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_35) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_34_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_34_(s, traits, 1, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_35) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_34_(s, traits, \ - is_static, next_assertion_macro) \ - BOOST_PP_EXPR_IIF(is_static, static) \ - if( \ - BOOST_PP_IIF( \ - BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND( \ - traits \ - ))) \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_35_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_35_ \ - )(s, BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND(traits), 0) \ - ) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)), \ - ( ) BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(next_assertion_macro, (), \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)) \ - else \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)), \ - ( ) BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(next_assertion_macro, (), \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)) - -// Extra parenthesis always internally added for if bool cond (so remove them). -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_34_(s, \ - cond_traits, has_trailing_comma) \ - BOOST_PP_TUPLE_REM_CTOR( BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_34_( \ - s, cond_traits, has_trailing_comma) ) - -#define BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_34_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_TYPE(traits)) \ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_ASSIGN(traits) \ - return \ - , - -// Implementation: OLDOF_..._OPERATOR internally splits tokens into a 2-tuple. -#define BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_34_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_TYPE(traits)) \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_ASSIGN(traits) \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_OPERATOR \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_EXPR(traits) \ - , - -/* PUBLIC (35) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_35( \ - s, assertions, assertion_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_35_(s, assertions, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_35_, assertion_traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_35( \ - s, assertions, assertion_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_35_(s, assertions, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_35_, assertion_traits) - -/* PRIVATE (35) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_35_( \ - s, assertions, assertion_macro, assertion_traits) \ - ( \ - BOOST_PP_TUPLE_REM_CTOR(assertions) \ - assertion_macro(s, assertion_traits) \ - ) - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_35_(s, traits) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_NAMESPACE_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_35_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_USING_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_35_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_TYPEDEF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_35_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_35_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_35_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_35_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_35_ \ - ))))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_35_(s, traits) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_RETURN_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_35_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_35_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_35_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_35_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_35_ \ - ))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_35_(s, traits) \ - namespace \ - (BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NEW_NAME(traits)) \ - as BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NAME(traits) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_35_(s, traits) \ - BOOST_PP_EXPR_IIF( \ - BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS( \ - traits \ - ) \ - )) \ - , \ - template \ - ) \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS(traits) \ - using \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAMESPACE(traits) \ - BOOST_PP_EXPR_IIF(BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits))), \ - (BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits)) as \ - ) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAME(traits)) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_35_(s, traits) \ - typedef \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NAME(traits)) \ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NEW_NAME(traits) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_35_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_35_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_35_(s, traits, \ - has_trailing_comma) \ - const \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)), \ - () BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(BOOST_CONTRACT_TEST_AUX_PP_CAPTURE_S_, (), \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)) \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_EXPR(traits) \ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_35_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_35_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_35_(s, traits, \ - has_trailing_comma) \ - BOOST_CONTRACT_EXT_PP_BOOL_ASSERTION_TRAITS_EXPR(traits) \ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_35_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_35_(s, traits, 0, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_36) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_35_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_35_(s, traits, 0, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_36) - -#define BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_35_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_35_(s, traits, 1, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_36) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_35_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_35_(s, traits, 1, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_36) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_35_(s, traits, \ - is_static, next_assertion_macro) \ - BOOST_PP_EXPR_IIF(is_static, static) \ - if( \ - BOOST_PP_IIF( \ - BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND( \ - traits \ - ))) \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_36_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_36_ \ - )(s, BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND(traits), 0) \ - ) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)), \ - ( ) BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(next_assertion_macro, (), \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)) \ - else \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)), \ - ( ) BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(next_assertion_macro, (), \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)) - -// Extra parenthesis always internally added for if bool cond (so remove them). -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_35_(s, \ - cond_traits, has_trailing_comma) \ - BOOST_PP_TUPLE_REM_CTOR( BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_35_( \ - s, cond_traits, has_trailing_comma) ) - -#define BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_35_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_TYPE(traits)) \ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_ASSIGN(traits) \ - return \ - , - -// Implementation: OLDOF_..._OPERATOR internally splits tokens into a 2-tuple. -#define BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_35_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_TYPE(traits)) \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_ASSIGN(traits) \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_OPERATOR \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_EXPR(traits) \ - , - -/* PUBLIC (36) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_36( \ - s, assertions, assertion_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_36_(s, assertions, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_36_, assertion_traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_36( \ - s, assertions, assertion_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_36_(s, assertions, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_36_, assertion_traits) - -/* PRIVATE (36) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_36_( \ - s, assertions, assertion_macro, assertion_traits) \ - ( \ - BOOST_PP_TUPLE_REM_CTOR(assertions) \ - assertion_macro(s, assertion_traits) \ - ) - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_36_(s, traits) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_NAMESPACE_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_36_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_USING_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_36_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_TYPEDEF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_36_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_36_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_36_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_36_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_36_ \ - ))))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_36_(s, traits) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_RETURN_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_36_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_36_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_36_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_36_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_36_ \ - ))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_36_(s, traits) \ - namespace \ - (BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NEW_NAME(traits)) \ - as BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NAME(traits) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_36_(s, traits) \ - BOOST_PP_EXPR_IIF( \ - BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS( \ - traits \ - ) \ - )) \ - , \ - template \ - ) \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS(traits) \ - using \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAMESPACE(traits) \ - BOOST_PP_EXPR_IIF(BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits))), \ - (BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits)) as \ - ) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAME(traits)) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_36_(s, traits) \ - typedef \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NAME(traits)) \ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NEW_NAME(traits) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_36_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_36_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_36_(s, traits, \ - has_trailing_comma) \ - const \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)), \ - () BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(BOOST_CONTRACT_TEST_AUX_PP_CAPTURE_S_, (), \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)) \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_EXPR(traits) \ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_36_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_36_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_36_(s, traits, \ - has_trailing_comma) \ - BOOST_CONTRACT_EXT_PP_BOOL_ASSERTION_TRAITS_EXPR(traits) \ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_36_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_36_(s, traits, 0, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_37) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_36_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_36_(s, traits, 0, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_37) - -#define BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_36_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_36_(s, traits, 1, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_37) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_36_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_36_(s, traits, 1, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_37) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_36_(s, traits, \ - is_static, next_assertion_macro) \ - BOOST_PP_EXPR_IIF(is_static, static) \ - if( \ - BOOST_PP_IIF( \ - BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND( \ - traits \ - ))) \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_37_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_37_ \ - )(s, BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND(traits), 0) \ - ) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)), \ - ( ) BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(next_assertion_macro, (), \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)) \ - else \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)), \ - ( ) BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(next_assertion_macro, (), \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)) - -// Extra parenthesis always internally added for if bool cond (so remove them). -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_36_(s, \ - cond_traits, has_trailing_comma) \ - BOOST_PP_TUPLE_REM_CTOR( BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_36_( \ - s, cond_traits, has_trailing_comma) ) - -#define BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_36_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_TYPE(traits)) \ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_ASSIGN(traits) \ - return \ - , - -// Implementation: OLDOF_..._OPERATOR internally splits tokens into a 2-tuple. -#define BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_36_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_TYPE(traits)) \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_ASSIGN(traits) \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_OPERATOR \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_EXPR(traits) \ - , - -/* PUBLIC (37) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_37( \ - s, assertions, assertion_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_37_(s, assertions, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_37_, assertion_traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_37( \ - s, assertions, assertion_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_37_(s, assertions, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_37_, assertion_traits) - -/* PRIVATE (37) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_37_( \ - s, assertions, assertion_macro, assertion_traits) \ - ( \ - BOOST_PP_TUPLE_REM_CTOR(assertions) \ - assertion_macro(s, assertion_traits) \ - ) - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_37_(s, traits) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_NAMESPACE_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_37_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_USING_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_37_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_TYPEDEF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_37_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_37_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_37_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_37_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_37_ \ - ))))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_37_(s, traits) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_RETURN_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_37_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_37_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_37_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_37_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_37_ \ - ))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_37_(s, traits) \ - namespace \ - (BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NEW_NAME(traits)) \ - as BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NAME(traits) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_37_(s, traits) \ - BOOST_PP_EXPR_IIF( \ - BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS( \ - traits \ - ) \ - )) \ - , \ - template \ - ) \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS(traits) \ - using \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAMESPACE(traits) \ - BOOST_PP_EXPR_IIF(BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits))), \ - (BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits)) as \ - ) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAME(traits)) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_37_(s, traits) \ - typedef \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NAME(traits)) \ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NEW_NAME(traits) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_37_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_37_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_37_(s, traits, \ - has_trailing_comma) \ - const \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)), \ - () BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(BOOST_CONTRACT_TEST_AUX_PP_CAPTURE_S_, (), \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)) \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_EXPR(traits) \ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_37_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_37_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_37_(s, traits, \ - has_trailing_comma) \ - BOOST_CONTRACT_EXT_PP_BOOL_ASSERTION_TRAITS_EXPR(traits) \ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_37_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_37_(s, traits, 0, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_38) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_37_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_37_(s, traits, 0, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_38) - -#define BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_37_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_37_(s, traits, 1, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_38) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_37_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_37_(s, traits, 1, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_38) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_37_(s, traits, \ - is_static, next_assertion_macro) \ - BOOST_PP_EXPR_IIF(is_static, static) \ - if( \ - BOOST_PP_IIF( \ - BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND( \ - traits \ - ))) \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_38_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_38_ \ - )(s, BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND(traits), 0) \ - ) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)), \ - ( ) BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(next_assertion_macro, (), \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)) \ - else \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)), \ - ( ) BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(next_assertion_macro, (), \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)) - -// Extra parenthesis always internally added for if bool cond (so remove them). -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_37_(s, \ - cond_traits, has_trailing_comma) \ - BOOST_PP_TUPLE_REM_CTOR( BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_37_( \ - s, cond_traits, has_trailing_comma) ) - -#define BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_37_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_TYPE(traits)) \ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_ASSIGN(traits) \ - return \ - , - -// Implementation: OLDOF_..._OPERATOR internally splits tokens into a 2-tuple. -#define BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_37_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_TYPE(traits)) \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_ASSIGN(traits) \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_OPERATOR \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_EXPR(traits) \ - , - -/* PUBLIC (38) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_38( \ - s, assertions, assertion_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_38_(s, assertions, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_38_, assertion_traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_38( \ - s, assertions, assertion_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_38_(s, assertions, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_38_, assertion_traits) - -/* PRIVATE (38) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_38_( \ - s, assertions, assertion_macro, assertion_traits) \ - ( \ - BOOST_PP_TUPLE_REM_CTOR(assertions) \ - assertion_macro(s, assertion_traits) \ - ) - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_38_(s, traits) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_NAMESPACE_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_38_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_USING_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_38_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_TYPEDEF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_38_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_38_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_38_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_38_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_38_ \ - ))))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_38_(s, traits) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_RETURN_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_38_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_38_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_38_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_38_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_38_ \ - ))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_38_(s, traits) \ - namespace \ - (BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NEW_NAME(traits)) \ - as BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NAME(traits) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_38_(s, traits) \ - BOOST_PP_EXPR_IIF( \ - BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS( \ - traits \ - ) \ - )) \ - , \ - template \ - ) \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS(traits) \ - using \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAMESPACE(traits) \ - BOOST_PP_EXPR_IIF(BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits))), \ - (BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits)) as \ - ) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAME(traits)) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_38_(s, traits) \ - typedef \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NAME(traits)) \ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NEW_NAME(traits) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_38_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_38_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_38_(s, traits, \ - has_trailing_comma) \ - const \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)), \ - () BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(BOOST_CONTRACT_TEST_AUX_PP_CAPTURE_S_, (), \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)) \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_EXPR(traits) \ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_38_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_38_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_38_(s, traits, \ - has_trailing_comma) \ - BOOST_CONTRACT_EXT_PP_BOOL_ASSERTION_TRAITS_EXPR(traits) \ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_38_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_38_(s, traits, 0, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_39) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_38_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_38_(s, traits, 0, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_39) - -#define BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_38_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_38_(s, traits, 1, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_39) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_38_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_38_(s, traits, 1, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_39) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_38_(s, traits, \ - is_static, next_assertion_macro) \ - BOOST_PP_EXPR_IIF(is_static, static) \ - if( \ - BOOST_PP_IIF( \ - BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND( \ - traits \ - ))) \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_39_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_39_ \ - )(s, BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND(traits), 0) \ - ) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)), \ - ( ) BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(next_assertion_macro, (), \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)) \ - else \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)), \ - ( ) BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(next_assertion_macro, (), \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)) - -// Extra parenthesis always internally added for if bool cond (so remove them). -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_38_(s, \ - cond_traits, has_trailing_comma) \ - BOOST_PP_TUPLE_REM_CTOR( BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_38_( \ - s, cond_traits, has_trailing_comma) ) - -#define BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_38_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_TYPE(traits)) \ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_ASSIGN(traits) \ - return \ - , - -// Implementation: OLDOF_..._OPERATOR internally splits tokens into a 2-tuple. -#define BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_38_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_TYPE(traits)) \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_ASSIGN(traits) \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_OPERATOR \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_EXPR(traits) \ - , - -/* PUBLIC (39) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_39( \ - s, assertions, assertion_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_39_(s, assertions, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_39_, assertion_traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_39( \ - s, assertions, assertion_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_39_(s, assertions, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_39_, assertion_traits) - -/* PRIVATE (39) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_39_( \ - s, assertions, assertion_macro, assertion_traits) \ - ( \ - BOOST_PP_TUPLE_REM_CTOR(assertions) \ - assertion_macro(s, assertion_traits) \ - ) - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_39_(s, traits) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_NAMESPACE_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_39_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_USING_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_39_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_TYPEDEF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_39_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_39_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_39_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_39_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_39_ \ - ))))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_39_(s, traits) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_RETURN_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_39_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_39_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_39_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_39_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_39_ \ - ))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_39_(s, traits) \ - namespace \ - (BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NEW_NAME(traits)) \ - as BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NAME(traits) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_39_(s, traits) \ - BOOST_PP_EXPR_IIF( \ - BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS( \ - traits \ - ) \ - )) \ - , \ - template \ - ) \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS(traits) \ - using \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAMESPACE(traits) \ - BOOST_PP_EXPR_IIF(BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits))), \ - (BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits)) as \ - ) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAME(traits)) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_39_(s, traits) \ - typedef \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NAME(traits)) \ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NEW_NAME(traits) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_39_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_39_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_39_(s, traits, \ - has_trailing_comma) \ - const \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)), \ - () BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(BOOST_CONTRACT_TEST_AUX_PP_CAPTURE_S_, (), \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)) \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_EXPR(traits) \ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_39_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_39_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_39_(s, traits, \ - has_trailing_comma) \ - BOOST_CONTRACT_EXT_PP_BOOL_ASSERTION_TRAITS_EXPR(traits) \ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_39_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_39_(s, traits, 0, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_40) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_39_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_39_(s, traits, 0, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_40) - -#define BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_39_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_39_(s, traits, 1, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_40) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_39_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_39_(s, traits, 1, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_40) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_39_(s, traits, \ - is_static, next_assertion_macro) \ - BOOST_PP_EXPR_IIF(is_static, static) \ - if( \ - BOOST_PP_IIF( \ - BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND( \ - traits \ - ))) \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_40_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_40_ \ - )(s, BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND(traits), 0) \ - ) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)), \ - ( ) BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(next_assertion_macro, (), \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)) \ - else \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)), \ - ( ) BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(next_assertion_macro, (), \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)) - -// Extra parenthesis always internally added for if bool cond (so remove them). -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_39_(s, \ - cond_traits, has_trailing_comma) \ - BOOST_PP_TUPLE_REM_CTOR( BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_39_( \ - s, cond_traits, has_trailing_comma) ) - -#define BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_39_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_TYPE(traits)) \ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_ASSIGN(traits) \ - return \ - , - -// Implementation: OLDOF_..._OPERATOR internally splits tokens into a 2-tuple. -#define BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_39_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_TYPE(traits)) \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_ASSIGN(traits) \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_OPERATOR \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_EXPR(traits) \ - , - -/* PUBLIC (40) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_40( \ - s, assertions, assertion_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_40_(s, assertions, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_40_, assertion_traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_40( \ - s, assertions, assertion_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_40_(s, assertions, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_40_, assertion_traits) - -/* PRIVATE (40) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_40_( \ - s, assertions, assertion_macro, assertion_traits) \ - ( \ - BOOST_PP_TUPLE_REM_CTOR(assertions) \ - assertion_macro(s, assertion_traits) \ - ) - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_40_(s, traits) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_NAMESPACE_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_40_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_USING_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_40_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_TYPEDEF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_40_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_40_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_40_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_40_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_40_ \ - ))))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_40_(s, traits) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_RETURN_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_40_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_40_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_40_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_40_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_40_ \ - ))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_40_(s, traits) \ - namespace \ - (BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NEW_NAME(traits)) \ - as BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NAME(traits) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_40_(s, traits) \ - BOOST_PP_EXPR_IIF( \ - BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS( \ - traits \ - ) \ - )) \ - , \ - template \ - ) \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS(traits) \ - using \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAMESPACE(traits) \ - BOOST_PP_EXPR_IIF(BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits))), \ - (BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits)) as \ - ) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAME(traits)) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_40_(s, traits) \ - typedef \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NAME(traits)) \ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NEW_NAME(traits) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_40_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_40_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_40_(s, traits, \ - has_trailing_comma) \ - const \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)), \ - () BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(BOOST_CONTRACT_TEST_AUX_PP_CAPTURE_S_, (), \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)) \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_EXPR(traits) \ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_40_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_40_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_40_(s, traits, \ - has_trailing_comma) \ - BOOST_CONTRACT_EXT_PP_BOOL_ASSERTION_TRAITS_EXPR(traits) \ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_40_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_40_(s, traits, 0, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_41) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_40_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_40_(s, traits, 0, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_41) - -#define BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_40_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_40_(s, traits, 1, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_41) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_40_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_40_(s, traits, 1, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_41) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_40_(s, traits, \ - is_static, next_assertion_macro) \ - BOOST_PP_EXPR_IIF(is_static, static) \ - if( \ - BOOST_PP_IIF( \ - BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND( \ - traits \ - ))) \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_41_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_41_ \ - )(s, BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND(traits), 0) \ - ) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)), \ - ( ) BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(next_assertion_macro, (), \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)) \ - else \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)), \ - ( ) BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(next_assertion_macro, (), \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)) - -// Extra parenthesis always internally added for if bool cond (so remove them). -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_40_(s, \ - cond_traits, has_trailing_comma) \ - BOOST_PP_TUPLE_REM_CTOR( BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_40_( \ - s, cond_traits, has_trailing_comma) ) - -#define BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_40_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_TYPE(traits)) \ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_ASSIGN(traits) \ - return \ - , - -// Implementation: OLDOF_..._OPERATOR internally splits tokens into a 2-tuple. -#define BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_40_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_TYPE(traits)) \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_ASSIGN(traits) \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_OPERATOR \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_EXPR(traits) \ - , - -/* PUBLIC (41) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_41( \ - s, assertions, assertion_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_41_(s, assertions, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_41_, assertion_traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_41( \ - s, assertions, assertion_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_41_(s, assertions, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_41_, assertion_traits) - -/* PRIVATE (41) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_41_( \ - s, assertions, assertion_macro, assertion_traits) \ - ( \ - BOOST_PP_TUPLE_REM_CTOR(assertions) \ - assertion_macro(s, assertion_traits) \ - ) - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_41_(s, traits) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_NAMESPACE_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_41_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_USING_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_41_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_TYPEDEF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_41_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_41_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_41_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_41_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_41_ \ - ))))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_41_(s, traits) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_RETURN_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_41_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_41_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_41_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_41_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_41_ \ - ))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_41_(s, traits) \ - namespace \ - (BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NEW_NAME(traits)) \ - as BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NAME(traits) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_41_(s, traits) \ - BOOST_PP_EXPR_IIF( \ - BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS( \ - traits \ - ) \ - )) \ - , \ - template \ - ) \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS(traits) \ - using \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAMESPACE(traits) \ - BOOST_PP_EXPR_IIF(BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits))), \ - (BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits)) as \ - ) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAME(traits)) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_41_(s, traits) \ - typedef \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NAME(traits)) \ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NEW_NAME(traits) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_41_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_41_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_41_(s, traits, \ - has_trailing_comma) \ - const \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)), \ - () BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(BOOST_CONTRACT_TEST_AUX_PP_CAPTURE_S_, (), \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)) \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_EXPR(traits) \ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_41_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_41_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_41_(s, traits, \ - has_trailing_comma) \ - BOOST_CONTRACT_EXT_PP_BOOL_ASSERTION_TRAITS_EXPR(traits) \ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_41_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_41_(s, traits, 0, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_42) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_41_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_41_(s, traits, 0, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_42) - -#define BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_41_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_41_(s, traits, 1, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_42) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_41_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_41_(s, traits, 1, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_42) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_41_(s, traits, \ - is_static, next_assertion_macro) \ - BOOST_PP_EXPR_IIF(is_static, static) \ - if( \ - BOOST_PP_IIF( \ - BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND( \ - traits \ - ))) \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_42_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_42_ \ - )(s, BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND(traits), 0) \ - ) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)), \ - ( ) BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(next_assertion_macro, (), \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)) \ - else \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)), \ - ( ) BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(next_assertion_macro, (), \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)) - -// Extra parenthesis always internally added for if bool cond (so remove them). -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_41_(s, \ - cond_traits, has_trailing_comma) \ - BOOST_PP_TUPLE_REM_CTOR( BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_41_( \ - s, cond_traits, has_trailing_comma) ) - -#define BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_41_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_TYPE(traits)) \ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_ASSIGN(traits) \ - return \ - , - -// Implementation: OLDOF_..._OPERATOR internally splits tokens into a 2-tuple. -#define BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_41_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_TYPE(traits)) \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_ASSIGN(traits) \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_OPERATOR \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_EXPR(traits) \ - , - -/* PUBLIC (42) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_42( \ - s, assertions, assertion_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_42_(s, assertions, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_42_, assertion_traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_42( \ - s, assertions, assertion_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_42_(s, assertions, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_42_, assertion_traits) - -/* PRIVATE (42) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_42_( \ - s, assertions, assertion_macro, assertion_traits) \ - ( \ - BOOST_PP_TUPLE_REM_CTOR(assertions) \ - assertion_macro(s, assertion_traits) \ - ) - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_42_(s, traits) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_NAMESPACE_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_42_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_USING_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_42_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_TYPEDEF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_42_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_42_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_42_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_42_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_42_ \ - ))))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_42_(s, traits) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_RETURN_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_42_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_42_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_42_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_42_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_42_ \ - ))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_42_(s, traits) \ - namespace \ - (BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NEW_NAME(traits)) \ - as BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NAME(traits) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_42_(s, traits) \ - BOOST_PP_EXPR_IIF( \ - BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS( \ - traits \ - ) \ - )) \ - , \ - template \ - ) \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS(traits) \ - using \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAMESPACE(traits) \ - BOOST_PP_EXPR_IIF(BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits))), \ - (BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits)) as \ - ) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAME(traits)) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_42_(s, traits) \ - typedef \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NAME(traits)) \ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NEW_NAME(traits) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_42_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_42_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_42_(s, traits, \ - has_trailing_comma) \ - const \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)), \ - () BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(BOOST_CONTRACT_TEST_AUX_PP_CAPTURE_S_, (), \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)) \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_EXPR(traits) \ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_42_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_42_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_42_(s, traits, \ - has_trailing_comma) \ - BOOST_CONTRACT_EXT_PP_BOOL_ASSERTION_TRAITS_EXPR(traits) \ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_42_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_42_(s, traits, 0, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_43) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_42_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_42_(s, traits, 0, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_43) - -#define BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_42_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_42_(s, traits, 1, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_43) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_42_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_42_(s, traits, 1, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_43) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_42_(s, traits, \ - is_static, next_assertion_macro) \ - BOOST_PP_EXPR_IIF(is_static, static) \ - if( \ - BOOST_PP_IIF( \ - BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND( \ - traits \ - ))) \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_43_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_43_ \ - )(s, BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND(traits), 0) \ - ) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)), \ - ( ) BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(next_assertion_macro, (), \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)) \ - else \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)), \ - ( ) BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(next_assertion_macro, (), \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)) - -// Extra parenthesis always internally added for if bool cond (so remove them). -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_42_(s, \ - cond_traits, has_trailing_comma) \ - BOOST_PP_TUPLE_REM_CTOR( BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_42_( \ - s, cond_traits, has_trailing_comma) ) - -#define BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_42_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_TYPE(traits)) \ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_ASSIGN(traits) \ - return \ - , - -// Implementation: OLDOF_..._OPERATOR internally splits tokens into a 2-tuple. -#define BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_42_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_TYPE(traits)) \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_ASSIGN(traits) \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_OPERATOR \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_EXPR(traits) \ - , - -/* PUBLIC (43) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_43( \ - s, assertions, assertion_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_43_(s, assertions, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_43_, assertion_traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_43( \ - s, assertions, assertion_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_43_(s, assertions, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_43_, assertion_traits) - -/* PRIVATE (43) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_43_( \ - s, assertions, assertion_macro, assertion_traits) \ - ( \ - BOOST_PP_TUPLE_REM_CTOR(assertions) \ - assertion_macro(s, assertion_traits) \ - ) - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_43_(s, traits) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_NAMESPACE_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_43_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_USING_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_43_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_TYPEDEF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_43_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_43_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_43_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_43_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_43_ \ - ))))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_43_(s, traits) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_RETURN_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_43_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_43_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_43_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_43_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_43_ \ - ))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_43_(s, traits) \ - namespace \ - (BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NEW_NAME(traits)) \ - as BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NAME(traits) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_43_(s, traits) \ - BOOST_PP_EXPR_IIF( \ - BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS( \ - traits \ - ) \ - )) \ - , \ - template \ - ) \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS(traits) \ - using \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAMESPACE(traits) \ - BOOST_PP_EXPR_IIF(BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits))), \ - (BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits)) as \ - ) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAME(traits)) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_43_(s, traits) \ - typedef \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NAME(traits)) \ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NEW_NAME(traits) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_43_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_43_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_43_(s, traits, \ - has_trailing_comma) \ - const \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)), \ - () BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(BOOST_CONTRACT_TEST_AUX_PP_CAPTURE_S_, (), \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)) \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_EXPR(traits) \ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_43_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_43_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_43_(s, traits, \ - has_trailing_comma) \ - BOOST_CONTRACT_EXT_PP_BOOL_ASSERTION_TRAITS_EXPR(traits) \ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_43_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_43_(s, traits, 0, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_44) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_43_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_43_(s, traits, 0, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_44) - -#define BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_43_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_43_(s, traits, 1, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_44) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_43_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_43_(s, traits, 1, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_44) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_43_(s, traits, \ - is_static, next_assertion_macro) \ - BOOST_PP_EXPR_IIF(is_static, static) \ - if( \ - BOOST_PP_IIF( \ - BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND( \ - traits \ - ))) \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_44_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_44_ \ - )(s, BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND(traits), 0) \ - ) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)), \ - ( ) BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(next_assertion_macro, (), \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)) \ - else \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)), \ - ( ) BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(next_assertion_macro, (), \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)) - -// Extra parenthesis always internally added for if bool cond (so remove them). -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_43_(s, \ - cond_traits, has_trailing_comma) \ - BOOST_PP_TUPLE_REM_CTOR( BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_43_( \ - s, cond_traits, has_trailing_comma) ) - -#define BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_43_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_TYPE(traits)) \ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_ASSIGN(traits) \ - return \ - , - -// Implementation: OLDOF_..._OPERATOR internally splits tokens into a 2-tuple. -#define BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_43_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_TYPE(traits)) \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_ASSIGN(traits) \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_OPERATOR \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_EXPR(traits) \ - , - -/* PUBLIC (44) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_44( \ - s, assertions, assertion_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_44_(s, assertions, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_44_, assertion_traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_44( \ - s, assertions, assertion_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_44_(s, assertions, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_44_, assertion_traits) - -/* PRIVATE (44) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_44_( \ - s, assertions, assertion_macro, assertion_traits) \ - ( \ - BOOST_PP_TUPLE_REM_CTOR(assertions) \ - assertion_macro(s, assertion_traits) \ - ) - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_44_(s, traits) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_NAMESPACE_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_44_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_USING_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_44_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_TYPEDEF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_44_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_44_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_44_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_44_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_44_ \ - ))))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_44_(s, traits) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_RETURN_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_44_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_44_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_44_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_44_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_44_ \ - ))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_44_(s, traits) \ - namespace \ - (BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NEW_NAME(traits)) \ - as BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NAME(traits) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_44_(s, traits) \ - BOOST_PP_EXPR_IIF( \ - BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS( \ - traits \ - ) \ - )) \ - , \ - template \ - ) \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS(traits) \ - using \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAMESPACE(traits) \ - BOOST_PP_EXPR_IIF(BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits))), \ - (BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits)) as \ - ) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAME(traits)) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_44_(s, traits) \ - typedef \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NAME(traits)) \ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NEW_NAME(traits) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_44_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_44_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_44_(s, traits, \ - has_trailing_comma) \ - const \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)), \ - () BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(BOOST_CONTRACT_TEST_AUX_PP_CAPTURE_S_, (), \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)) \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_EXPR(traits) \ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_44_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_44_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_44_(s, traits, \ - has_trailing_comma) \ - BOOST_CONTRACT_EXT_PP_BOOL_ASSERTION_TRAITS_EXPR(traits) \ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_44_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_44_(s, traits, 0, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_45) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_44_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_44_(s, traits, 0, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_45) - -#define BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_44_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_44_(s, traits, 1, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_45) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_44_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_44_(s, traits, 1, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_45) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_44_(s, traits, \ - is_static, next_assertion_macro) \ - BOOST_PP_EXPR_IIF(is_static, static) \ - if( \ - BOOST_PP_IIF( \ - BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND( \ - traits \ - ))) \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_45_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_45_ \ - )(s, BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND(traits), 0) \ - ) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)), \ - ( ) BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(next_assertion_macro, (), \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)) \ - else \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)), \ - ( ) BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(next_assertion_macro, (), \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)) - -// Extra parenthesis always internally added for if bool cond (so remove them). -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_44_(s, \ - cond_traits, has_trailing_comma) \ - BOOST_PP_TUPLE_REM_CTOR( BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_44_( \ - s, cond_traits, has_trailing_comma) ) - -#define BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_44_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_TYPE(traits)) \ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_ASSIGN(traits) \ - return \ - , - -// Implementation: OLDOF_..._OPERATOR internally splits tokens into a 2-tuple. -#define BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_44_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_TYPE(traits)) \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_ASSIGN(traits) \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_OPERATOR \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_EXPR(traits) \ - , - -/* PUBLIC (45) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_45( \ - s, assertions, assertion_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_45_(s, assertions, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_45_, assertion_traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_45( \ - s, assertions, assertion_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_45_(s, assertions, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_45_, assertion_traits) - -/* PRIVATE (45) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_45_( \ - s, assertions, assertion_macro, assertion_traits) \ - ( \ - BOOST_PP_TUPLE_REM_CTOR(assertions) \ - assertion_macro(s, assertion_traits) \ - ) - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_45_(s, traits) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_NAMESPACE_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_45_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_USING_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_45_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_TYPEDEF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_45_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_45_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_45_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_45_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_45_ \ - ))))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_45_(s, traits) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_RETURN_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_45_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_45_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_45_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_45_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_45_ \ - ))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_45_(s, traits) \ - namespace \ - (BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NEW_NAME(traits)) \ - as BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NAME(traits) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_45_(s, traits) \ - BOOST_PP_EXPR_IIF( \ - BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS( \ - traits \ - ) \ - )) \ - , \ - template \ - ) \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS(traits) \ - using \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAMESPACE(traits) \ - BOOST_PP_EXPR_IIF(BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits))), \ - (BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits)) as \ - ) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAME(traits)) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_45_(s, traits) \ - typedef \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NAME(traits)) \ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NEW_NAME(traits) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_45_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_45_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_45_(s, traits, \ - has_trailing_comma) \ - const \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)), \ - () BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(BOOST_CONTRACT_TEST_AUX_PP_CAPTURE_S_, (), \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)) \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_EXPR(traits) \ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_45_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_45_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_45_(s, traits, \ - has_trailing_comma) \ - BOOST_CONTRACT_EXT_PP_BOOL_ASSERTION_TRAITS_EXPR(traits) \ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_45_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_45_(s, traits, 0, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_46) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_45_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_45_(s, traits, 0, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_46) - -#define BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_45_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_45_(s, traits, 1, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_46) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_45_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_45_(s, traits, 1, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_46) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_45_(s, traits, \ - is_static, next_assertion_macro) \ - BOOST_PP_EXPR_IIF(is_static, static) \ - if( \ - BOOST_PP_IIF( \ - BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND( \ - traits \ - ))) \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_46_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_46_ \ - )(s, BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND(traits), 0) \ - ) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)), \ - ( ) BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(next_assertion_macro, (), \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)) \ - else \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)), \ - ( ) BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(next_assertion_macro, (), \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)) - -// Extra parenthesis always internally added for if bool cond (so remove them). -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_45_(s, \ - cond_traits, has_trailing_comma) \ - BOOST_PP_TUPLE_REM_CTOR( BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_45_( \ - s, cond_traits, has_trailing_comma) ) - -#define BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_45_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_TYPE(traits)) \ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_ASSIGN(traits) \ - return \ - , - -// Implementation: OLDOF_..._OPERATOR internally splits tokens into a 2-tuple. -#define BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_45_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_TYPE(traits)) \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_ASSIGN(traits) \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_OPERATOR \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_EXPR(traits) \ - , - -/* PUBLIC (46) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_46( \ - s, assertions, assertion_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_46_(s, assertions, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_46_, assertion_traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_46( \ - s, assertions, assertion_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_46_(s, assertions, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_46_, assertion_traits) - -/* PRIVATE (46) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_46_( \ - s, assertions, assertion_macro, assertion_traits) \ - ( \ - BOOST_PP_TUPLE_REM_CTOR(assertions) \ - assertion_macro(s, assertion_traits) \ - ) - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_46_(s, traits) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_NAMESPACE_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_46_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_USING_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_46_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_TYPEDEF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_46_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_46_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_46_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_46_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_46_ \ - ))))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_46_(s, traits) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_RETURN_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_46_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_46_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_46_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_46_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_46_ \ - ))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_46_(s, traits) \ - namespace \ - (BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NEW_NAME(traits)) \ - as BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NAME(traits) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_46_(s, traits) \ - BOOST_PP_EXPR_IIF( \ - BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS( \ - traits \ - ) \ - )) \ - , \ - template \ - ) \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS(traits) \ - using \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAMESPACE(traits) \ - BOOST_PP_EXPR_IIF(BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits))), \ - (BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits)) as \ - ) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAME(traits)) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_46_(s, traits) \ - typedef \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NAME(traits)) \ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NEW_NAME(traits) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_46_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_46_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_46_(s, traits, \ - has_trailing_comma) \ - const \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)), \ - () BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(BOOST_CONTRACT_TEST_AUX_PP_CAPTURE_S_, (), \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)) \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_EXPR(traits) \ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_46_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_46_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_46_(s, traits, \ - has_trailing_comma) \ - BOOST_CONTRACT_EXT_PP_BOOL_ASSERTION_TRAITS_EXPR(traits) \ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_46_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_46_(s, traits, 0, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_47) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_46_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_46_(s, traits, 0, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_47) - -#define BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_46_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_46_(s, traits, 1, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_47) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_46_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_46_(s, traits, 1, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_47) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_46_(s, traits, \ - is_static, next_assertion_macro) \ - BOOST_PP_EXPR_IIF(is_static, static) \ - if( \ - BOOST_PP_IIF( \ - BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND( \ - traits \ - ))) \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_47_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_47_ \ - )(s, BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND(traits), 0) \ - ) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)), \ - ( ) BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(next_assertion_macro, (), \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)) \ - else \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)), \ - ( ) BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(next_assertion_macro, (), \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)) - -// Extra parenthesis always internally added for if bool cond (so remove them). -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_46_(s, \ - cond_traits, has_trailing_comma) \ - BOOST_PP_TUPLE_REM_CTOR( BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_46_( \ - s, cond_traits, has_trailing_comma) ) - -#define BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_46_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_TYPE(traits)) \ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_ASSIGN(traits) \ - return \ - , - -// Implementation: OLDOF_..._OPERATOR internally splits tokens into a 2-tuple. -#define BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_46_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_TYPE(traits)) \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_ASSIGN(traits) \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_OPERATOR \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_EXPR(traits) \ - , - -/* PUBLIC (47) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_47( \ - s, assertions, assertion_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_47_(s, assertions, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_47_, assertion_traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_47( \ - s, assertions, assertion_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_47_(s, assertions, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_47_, assertion_traits) - -/* PRIVATE (47) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_47_( \ - s, assertions, assertion_macro, assertion_traits) \ - ( \ - BOOST_PP_TUPLE_REM_CTOR(assertions) \ - assertion_macro(s, assertion_traits) \ - ) - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_47_(s, traits) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_NAMESPACE_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_47_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_USING_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_47_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_TYPEDEF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_47_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_47_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_47_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_47_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_47_ \ - ))))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_47_(s, traits) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_RETURN_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_47_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_47_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_47_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_47_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_47_ \ - ))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_47_(s, traits) \ - namespace \ - (BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NEW_NAME(traits)) \ - as BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NAME(traits) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_47_(s, traits) \ - BOOST_PP_EXPR_IIF( \ - BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS( \ - traits \ - ) \ - )) \ - , \ - template \ - ) \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS(traits) \ - using \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAMESPACE(traits) \ - BOOST_PP_EXPR_IIF(BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits))), \ - (BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits)) as \ - ) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAME(traits)) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_47_(s, traits) \ - typedef \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NAME(traits)) \ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NEW_NAME(traits) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_47_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_47_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_47_(s, traits, \ - has_trailing_comma) \ - const \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)), \ - () BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(BOOST_CONTRACT_TEST_AUX_PP_CAPTURE_S_, (), \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)) \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_EXPR(traits) \ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_47_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_47_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_47_(s, traits, \ - has_trailing_comma) \ - BOOST_CONTRACT_EXT_PP_BOOL_ASSERTION_TRAITS_EXPR(traits) \ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_47_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_47_(s, traits, 0, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_48) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_47_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_47_(s, traits, 0, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_48) - -#define BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_47_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_47_(s, traits, 1, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_48) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_47_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_47_(s, traits, 1, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_48) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_47_(s, traits, \ - is_static, next_assertion_macro) \ - BOOST_PP_EXPR_IIF(is_static, static) \ - if( \ - BOOST_PP_IIF( \ - BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND( \ - traits \ - ))) \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_48_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_48_ \ - )(s, BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND(traits), 0) \ - ) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)), \ - ( ) BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(next_assertion_macro, (), \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)) \ - else \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)), \ - ( ) BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(next_assertion_macro, (), \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)) - -// Extra parenthesis always internally added for if bool cond (so remove them). -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_47_(s, \ - cond_traits, has_trailing_comma) \ - BOOST_PP_TUPLE_REM_CTOR( BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_47_( \ - s, cond_traits, has_trailing_comma) ) - -#define BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_47_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_TYPE(traits)) \ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_ASSIGN(traits) \ - return \ - , - -// Implementation: OLDOF_..._OPERATOR internally splits tokens into a 2-tuple. -#define BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_47_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_TYPE(traits)) \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_ASSIGN(traits) \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_OPERATOR \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_EXPR(traits) \ - , - -/* PUBLIC (48) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_48( \ - s, assertions, assertion_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_48_(s, assertions, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_48_, assertion_traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_48( \ - s, assertions, assertion_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_48_(s, assertions, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_48_, assertion_traits) - -/* PRIVATE (48) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_48_( \ - s, assertions, assertion_macro, assertion_traits) \ - ( \ - BOOST_PP_TUPLE_REM_CTOR(assertions) \ - assertion_macro(s, assertion_traits) \ - ) - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_48_(s, traits) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_NAMESPACE_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_48_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_USING_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_48_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_TYPEDEF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_48_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_48_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_48_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_48_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_48_ \ - ))))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_48_(s, traits) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_RETURN_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_48_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_48_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_48_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_48_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_48_ \ - ))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_48_(s, traits) \ - namespace \ - (BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NEW_NAME(traits)) \ - as BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NAME(traits) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_48_(s, traits) \ - BOOST_PP_EXPR_IIF( \ - BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS( \ - traits \ - ) \ - )) \ - , \ - template \ - ) \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS(traits) \ - using \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAMESPACE(traits) \ - BOOST_PP_EXPR_IIF(BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits))), \ - (BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits)) as \ - ) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAME(traits)) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_48_(s, traits) \ - typedef \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NAME(traits)) \ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NEW_NAME(traits) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_48_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_48_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_48_(s, traits, \ - has_trailing_comma) \ - const \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)), \ - () BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(BOOST_CONTRACT_TEST_AUX_PP_CAPTURE_S_, (), \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)) \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_EXPR(traits) \ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_48_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_48_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_48_(s, traits, \ - has_trailing_comma) \ - BOOST_CONTRACT_EXT_PP_BOOL_ASSERTION_TRAITS_EXPR(traits) \ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_48_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_48_(s, traits, 0, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_49) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_48_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_48_(s, traits, 0, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_49) - -#define BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_48_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_48_(s, traits, 1, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_49) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_48_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_48_(s, traits, 1, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_49) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_48_(s, traits, \ - is_static, next_assertion_macro) \ - BOOST_PP_EXPR_IIF(is_static, static) \ - if( \ - BOOST_PP_IIF( \ - BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND( \ - traits \ - ))) \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_49_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_49_ \ - )(s, BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND(traits), 0) \ - ) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)), \ - ( ) BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(next_assertion_macro, (), \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)) \ - else \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)), \ - ( ) BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(next_assertion_macro, (), \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)) - -// Extra parenthesis always internally added for if bool cond (so remove them). -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_48_(s, \ - cond_traits, has_trailing_comma) \ - BOOST_PP_TUPLE_REM_CTOR( BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_48_( \ - s, cond_traits, has_trailing_comma) ) - -#define BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_48_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_TYPE(traits)) \ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_ASSIGN(traits) \ - return \ - , - -// Implementation: OLDOF_..._OPERATOR internally splits tokens into a 2-tuple. -#define BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_48_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_TYPE(traits)) \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_ASSIGN(traits) \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_OPERATOR \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_EXPR(traits) \ - , - -/* PUBLIC (49) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_49( \ - s, assertions, assertion_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_49_(s, assertions, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_49_, assertion_traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_49( \ - s, assertions, assertion_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_49_(s, assertions, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_49_, assertion_traits) - -/* PRIVATE (49) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_49_( \ - s, assertions, assertion_macro, assertion_traits) \ - ( \ - BOOST_PP_TUPLE_REM_CTOR(assertions) \ - assertion_macro(s, assertion_traits) \ - ) - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_49_(s, traits) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_NAMESPACE_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_49_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_USING_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_49_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_TYPEDEF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_49_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_49_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_49_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_49_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_49_ \ - ))))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_49_(s, traits) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_RETURN_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_49_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_49_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_49_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_49_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_49_ \ - ))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_49_(s, traits) \ - namespace \ - (BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NEW_NAME(traits)) \ - as BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NAME(traits) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_49_(s, traits) \ - BOOST_PP_EXPR_IIF( \ - BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS( \ - traits \ - ) \ - )) \ - , \ - template \ - ) \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS(traits) \ - using \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAMESPACE(traits) \ - BOOST_PP_EXPR_IIF(BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits))), \ - (BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits)) as \ - ) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAME(traits)) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_49_(s, traits) \ - typedef \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NAME(traits)) \ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NEW_NAME(traits) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_49_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_49_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_49_(s, traits, \ - has_trailing_comma) \ - const \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)), \ - () BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(BOOST_CONTRACT_TEST_AUX_PP_CAPTURE_S_, (), \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)) \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_EXPR(traits) \ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_49_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_49_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_49_(s, traits, \ - has_trailing_comma) \ - BOOST_CONTRACT_EXT_PP_BOOL_ASSERTION_TRAITS_EXPR(traits) \ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_49_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_49_(s, traits, 0, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_50) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_49_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_49_(s, traits, 0, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_50) - -#define BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_49_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_49_(s, traits, 1, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_50) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_49_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_49_(s, traits, 1, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_50) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_49_(s, traits, \ - is_static, next_assertion_macro) \ - BOOST_PP_EXPR_IIF(is_static, static) \ - if( \ - BOOST_PP_IIF( \ - BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND( \ - traits \ - ))) \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_50_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_50_ \ - )(s, BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND(traits), 0) \ - ) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)), \ - ( ) BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(next_assertion_macro, (), \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)) \ - else \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)), \ - ( ) BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(next_assertion_macro, (), \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)) - -// Extra parenthesis always internally added for if bool cond (so remove them). -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_49_(s, \ - cond_traits, has_trailing_comma) \ - BOOST_PP_TUPLE_REM_CTOR( BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_49_( \ - s, cond_traits, has_trailing_comma) ) - -#define BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_49_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_TYPE(traits)) \ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_ASSIGN(traits) \ - return \ - , - -// Implementation: OLDOF_..._OPERATOR internally splits tokens into a 2-tuple. -#define BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_49_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_TYPE(traits)) \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_ASSIGN(traits) \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_OPERATOR \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_EXPR(traits) \ - , - -/* PUBLIC (50) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_50( \ - s, assertions, assertion_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_50_(s, assertions, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_50_, assertion_traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_50( \ - s, assertions, assertion_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_50_(s, assertions, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_50_, assertion_traits) - -/* PRIVATE (50) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_50_( \ - s, assertions, assertion_macro, assertion_traits) \ - ( \ - BOOST_PP_TUPLE_REM_CTOR(assertions) \ - assertion_macro(s, assertion_traits) \ - ) - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_50_(s, traits) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_NAMESPACE_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_50_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_USING_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_50_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_TYPEDEF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_50_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_50_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_50_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_50_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_50_ \ - ))))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_50_(s, traits) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_RETURN_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_50_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_50_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_50_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_50_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_50_ \ - ))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_50_(s, traits) \ - namespace \ - (BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NEW_NAME(traits)) \ - as BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NAME(traits) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_50_(s, traits) \ - BOOST_PP_EXPR_IIF( \ - BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS( \ - traits \ - ) \ - )) \ - , \ - template \ - ) \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS(traits) \ - using \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAMESPACE(traits) \ - BOOST_PP_EXPR_IIF(BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits))), \ - (BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits)) as \ - ) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAME(traits)) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_50_(s, traits) \ - typedef \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NAME(traits)) \ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NEW_NAME(traits) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_50_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_50_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_50_(s, traits, \ - has_trailing_comma) \ - const \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)), \ - () BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(BOOST_CONTRACT_TEST_AUX_PP_CAPTURE_S_, (), \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)) \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_EXPR(traits) \ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_50_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_50_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_50_(s, traits, \ - has_trailing_comma) \ - BOOST_CONTRACT_EXT_PP_BOOL_ASSERTION_TRAITS_EXPR(traits) \ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_50_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_50_(s, traits, 0, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_51) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_50_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_50_(s, traits, 0, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_51) - -#define BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_50_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_50_(s, traits, 1, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_51) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_50_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_50_(s, traits, 1, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_51) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_50_(s, traits, \ - is_static, next_assertion_macro) \ - BOOST_PP_EXPR_IIF(is_static, static) \ - if( \ - BOOST_PP_IIF( \ - BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND( \ - traits \ - ))) \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_51_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_51_ \ - )(s, BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND(traits), 0) \ - ) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)), \ - ( ) BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(next_assertion_macro, (), \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)) \ - else \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)), \ - ( ) BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(next_assertion_macro, (), \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)) - -// Extra parenthesis always internally added for if bool cond (so remove them). -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_50_(s, \ - cond_traits, has_trailing_comma) \ - BOOST_PP_TUPLE_REM_CTOR( BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_50_( \ - s, cond_traits, has_trailing_comma) ) - -#define BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_50_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_TYPE(traits)) \ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_ASSIGN(traits) \ - return \ - , - -// Implementation: OLDOF_..._OPERATOR internally splits tokens into a 2-tuple. -#define BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_50_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_TYPE(traits)) \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_ASSIGN(traits) \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_OPERATOR \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_EXPR(traits) \ - , - -/* PUBLIC (51) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_51( \ - s, assertions, assertion_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_51_(s, assertions, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_51_, assertion_traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_51( \ - s, assertions, assertion_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_51_(s, assertions, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_51_, assertion_traits) - -/* PRIVATE (51) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_51_( \ - s, assertions, assertion_macro, assertion_traits) \ - ( \ - BOOST_PP_TUPLE_REM_CTOR(assertions) \ - assertion_macro(s, assertion_traits) \ - ) - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_51_(s, traits) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_NAMESPACE_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_51_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_USING_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_51_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_TYPEDEF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_51_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_51_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_51_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_51_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_51_ \ - ))))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_51_(s, traits) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_RETURN_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_51_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_51_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_51_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_51_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_51_ \ - ))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_51_(s, traits) \ - namespace \ - (BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NEW_NAME(traits)) \ - as BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NAME(traits) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_51_(s, traits) \ - BOOST_PP_EXPR_IIF( \ - BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS( \ - traits \ - ) \ - )) \ - , \ - template \ - ) \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS(traits) \ - using \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAMESPACE(traits) \ - BOOST_PP_EXPR_IIF(BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits))), \ - (BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits)) as \ - ) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAME(traits)) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_51_(s, traits) \ - typedef \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NAME(traits)) \ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NEW_NAME(traits) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_51_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_51_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_51_(s, traits, \ - has_trailing_comma) \ - const \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)), \ - () BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(BOOST_CONTRACT_TEST_AUX_PP_CAPTURE_S_, (), \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)) \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_EXPR(traits) \ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_51_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_51_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_51_(s, traits, \ - has_trailing_comma) \ - BOOST_CONTRACT_EXT_PP_BOOL_ASSERTION_TRAITS_EXPR(traits) \ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_51_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_51_(s, traits, 0, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_52) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_51_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_51_(s, traits, 0, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_52) - -#define BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_51_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_51_(s, traits, 1, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_52) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_51_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_51_(s, traits, 1, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_52) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_51_(s, traits, \ - is_static, next_assertion_macro) \ - BOOST_PP_EXPR_IIF(is_static, static) \ - if( \ - BOOST_PP_IIF( \ - BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND( \ - traits \ - ))) \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_52_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_52_ \ - )(s, BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND(traits), 0) \ - ) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)), \ - ( ) BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(next_assertion_macro, (), \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)) \ - else \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)), \ - ( ) BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(next_assertion_macro, (), \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)) - -// Extra parenthesis always internally added for if bool cond (so remove them). -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_51_(s, \ - cond_traits, has_trailing_comma) \ - BOOST_PP_TUPLE_REM_CTOR( BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_51_( \ - s, cond_traits, has_trailing_comma) ) - -#define BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_51_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_TYPE(traits)) \ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_ASSIGN(traits) \ - return \ - , - -// Implementation: OLDOF_..._OPERATOR internally splits tokens into a 2-tuple. -#define BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_51_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_TYPE(traits)) \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_ASSIGN(traits) \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_OPERATOR \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_EXPR(traits) \ - , - -/* PUBLIC (52) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_52( \ - s, assertions, assertion_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_52_(s, assertions, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_52_, assertion_traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_52( \ - s, assertions, assertion_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_52_(s, assertions, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_52_, assertion_traits) - -/* PRIVATE (52) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_52_( \ - s, assertions, assertion_macro, assertion_traits) \ - ( \ - BOOST_PP_TUPLE_REM_CTOR(assertions) \ - assertion_macro(s, assertion_traits) \ - ) - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_52_(s, traits) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_NAMESPACE_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_52_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_USING_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_52_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_TYPEDEF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_52_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_52_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_52_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_52_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_52_ \ - ))))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_52_(s, traits) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_RETURN_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_52_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_52_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_52_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_52_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_52_ \ - ))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_52_(s, traits) \ - namespace \ - (BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NEW_NAME(traits)) \ - as BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NAME(traits) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_52_(s, traits) \ - BOOST_PP_EXPR_IIF( \ - BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS( \ - traits \ - ) \ - )) \ - , \ - template \ - ) \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS(traits) \ - using \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAMESPACE(traits) \ - BOOST_PP_EXPR_IIF(BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits))), \ - (BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits)) as \ - ) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAME(traits)) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_52_(s, traits) \ - typedef \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NAME(traits)) \ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NEW_NAME(traits) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_52_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_52_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_52_(s, traits, \ - has_trailing_comma) \ - const \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)), \ - () BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(BOOST_CONTRACT_TEST_AUX_PP_CAPTURE_S_, (), \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)) \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_EXPR(traits) \ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_52_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_52_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_52_(s, traits, \ - has_trailing_comma) \ - BOOST_CONTRACT_EXT_PP_BOOL_ASSERTION_TRAITS_EXPR(traits) \ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_52_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_52_(s, traits, 0, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_53) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_52_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_52_(s, traits, 0, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_53) - -#define BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_52_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_52_(s, traits, 1, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_53) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_52_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_52_(s, traits, 1, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_53) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_52_(s, traits, \ - is_static, next_assertion_macro) \ - BOOST_PP_EXPR_IIF(is_static, static) \ - if( \ - BOOST_PP_IIF( \ - BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND( \ - traits \ - ))) \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_53_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_53_ \ - )(s, BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND(traits), 0) \ - ) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)), \ - ( ) BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(next_assertion_macro, (), \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)) \ - else \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)), \ - ( ) BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(next_assertion_macro, (), \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)) - -// Extra parenthesis always internally added for if bool cond (so remove them). -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_52_(s, \ - cond_traits, has_trailing_comma) \ - BOOST_PP_TUPLE_REM_CTOR( BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_52_( \ - s, cond_traits, has_trailing_comma) ) - -#define BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_52_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_TYPE(traits)) \ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_ASSIGN(traits) \ - return \ - , - -// Implementation: OLDOF_..._OPERATOR internally splits tokens into a 2-tuple. -#define BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_52_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_TYPE(traits)) \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_ASSIGN(traits) \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_OPERATOR \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_EXPR(traits) \ - , - -/* PUBLIC (53) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_53( \ - s, assertions, assertion_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_53_(s, assertions, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_53_, assertion_traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_53( \ - s, assertions, assertion_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_53_(s, assertions, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_53_, assertion_traits) - -/* PRIVATE (53) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_53_( \ - s, assertions, assertion_macro, assertion_traits) \ - ( \ - BOOST_PP_TUPLE_REM_CTOR(assertions) \ - assertion_macro(s, assertion_traits) \ - ) - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_53_(s, traits) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_NAMESPACE_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_53_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_USING_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_53_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_TYPEDEF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_53_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_53_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_53_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_53_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_53_ \ - ))))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_53_(s, traits) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_RETURN_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_53_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_53_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_53_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_53_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_53_ \ - ))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_53_(s, traits) \ - namespace \ - (BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NEW_NAME(traits)) \ - as BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NAME(traits) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_53_(s, traits) \ - BOOST_PP_EXPR_IIF( \ - BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS( \ - traits \ - ) \ - )) \ - , \ - template \ - ) \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS(traits) \ - using \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAMESPACE(traits) \ - BOOST_PP_EXPR_IIF(BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits))), \ - (BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits)) as \ - ) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAME(traits)) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_53_(s, traits) \ - typedef \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NAME(traits)) \ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NEW_NAME(traits) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_53_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_53_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_53_(s, traits, \ - has_trailing_comma) \ - const \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)), \ - () BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(BOOST_CONTRACT_TEST_AUX_PP_CAPTURE_S_, (), \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)) \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_EXPR(traits) \ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_53_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_53_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_53_(s, traits, \ - has_trailing_comma) \ - BOOST_CONTRACT_EXT_PP_BOOL_ASSERTION_TRAITS_EXPR(traits) \ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_53_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_53_(s, traits, 0, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_54) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_53_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_53_(s, traits, 0, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_54) - -#define BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_53_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_53_(s, traits, 1, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_54) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_53_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_53_(s, traits, 1, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_54) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_53_(s, traits, \ - is_static, next_assertion_macro) \ - BOOST_PP_EXPR_IIF(is_static, static) \ - if( \ - BOOST_PP_IIF( \ - BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND( \ - traits \ - ))) \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_54_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_54_ \ - )(s, BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND(traits), 0) \ - ) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)), \ - ( ) BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(next_assertion_macro, (), \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)) \ - else \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)), \ - ( ) BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(next_assertion_macro, (), \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)) - -// Extra parenthesis always internally added for if bool cond (so remove them). -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_53_(s, \ - cond_traits, has_trailing_comma) \ - BOOST_PP_TUPLE_REM_CTOR( BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_53_( \ - s, cond_traits, has_trailing_comma) ) - -#define BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_53_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_TYPE(traits)) \ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_ASSIGN(traits) \ - return \ - , - -// Implementation: OLDOF_..._OPERATOR internally splits tokens into a 2-tuple. -#define BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_53_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_TYPE(traits)) \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_ASSIGN(traits) \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_OPERATOR \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_EXPR(traits) \ - , - -/* PUBLIC (54) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_54( \ - s, assertions, assertion_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_54_(s, assertions, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_54_, assertion_traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_54( \ - s, assertions, assertion_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_54_(s, assertions, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_54_, assertion_traits) - -/* PRIVATE (54) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_54_( \ - s, assertions, assertion_macro, assertion_traits) \ - ( \ - BOOST_PP_TUPLE_REM_CTOR(assertions) \ - assertion_macro(s, assertion_traits) \ - ) - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_54_(s, traits) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_NAMESPACE_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_54_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_USING_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_54_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_TYPEDEF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_54_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_54_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_54_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_54_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_54_ \ - ))))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_54_(s, traits) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_RETURN_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_54_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_54_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_54_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_54_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_54_ \ - ))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_54_(s, traits) \ - namespace \ - (BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NEW_NAME(traits)) \ - as BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NAME(traits) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_54_(s, traits) \ - BOOST_PP_EXPR_IIF( \ - BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS( \ - traits \ - ) \ - )) \ - , \ - template \ - ) \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS(traits) \ - using \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAMESPACE(traits) \ - BOOST_PP_EXPR_IIF(BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits))), \ - (BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits)) as \ - ) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAME(traits)) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_54_(s, traits) \ - typedef \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NAME(traits)) \ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NEW_NAME(traits) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_54_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_54_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_54_(s, traits, \ - has_trailing_comma) \ - const \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)), \ - () BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(BOOST_CONTRACT_TEST_AUX_PP_CAPTURE_S_, (), \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)) \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_EXPR(traits) \ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_54_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_54_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_54_(s, traits, \ - has_trailing_comma) \ - BOOST_CONTRACT_EXT_PP_BOOL_ASSERTION_TRAITS_EXPR(traits) \ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_54_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_54_(s, traits, 0, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_55) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_54_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_54_(s, traits, 0, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_55) - -#define BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_54_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_54_(s, traits, 1, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_55) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_54_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_54_(s, traits, 1, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_55) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_54_(s, traits, \ - is_static, next_assertion_macro) \ - BOOST_PP_EXPR_IIF(is_static, static) \ - if( \ - BOOST_PP_IIF( \ - BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND( \ - traits \ - ))) \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_55_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_55_ \ - )(s, BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND(traits), 0) \ - ) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)), \ - ( ) BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(next_assertion_macro, (), \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)) \ - else \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)), \ - ( ) BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(next_assertion_macro, (), \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)) - -// Extra parenthesis always internally added for if bool cond (so remove them). -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_54_(s, \ - cond_traits, has_trailing_comma) \ - BOOST_PP_TUPLE_REM_CTOR( BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_54_( \ - s, cond_traits, has_trailing_comma) ) - -#define BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_54_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_TYPE(traits)) \ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_ASSIGN(traits) \ - return \ - , - -// Implementation: OLDOF_..._OPERATOR internally splits tokens into a 2-tuple. -#define BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_54_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_TYPE(traits)) \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_ASSIGN(traits) \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_OPERATOR \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_EXPR(traits) \ - , - -/* PUBLIC (55) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_55( \ - s, assertions, assertion_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_55_(s, assertions, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_55_, assertion_traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_55( \ - s, assertions, assertion_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_55_(s, assertions, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_55_, assertion_traits) - -/* PRIVATE (55) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_55_( \ - s, assertions, assertion_macro, assertion_traits) \ - ( \ - BOOST_PP_TUPLE_REM_CTOR(assertions) \ - assertion_macro(s, assertion_traits) \ - ) - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_55_(s, traits) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_NAMESPACE_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_55_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_USING_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_55_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_TYPEDEF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_55_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_55_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_55_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_55_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_55_ \ - ))))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_55_(s, traits) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_RETURN_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_55_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_55_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_55_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_55_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_55_ \ - ))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_55_(s, traits) \ - namespace \ - (BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NEW_NAME(traits)) \ - as BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NAME(traits) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_55_(s, traits) \ - BOOST_PP_EXPR_IIF( \ - BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS( \ - traits \ - ) \ - )) \ - , \ - template \ - ) \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS(traits) \ - using \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAMESPACE(traits) \ - BOOST_PP_EXPR_IIF(BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits))), \ - (BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits)) as \ - ) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAME(traits)) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_55_(s, traits) \ - typedef \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NAME(traits)) \ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NEW_NAME(traits) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_55_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_55_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_55_(s, traits, \ - has_trailing_comma) \ - const \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)), \ - () BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(BOOST_CONTRACT_TEST_AUX_PP_CAPTURE_S_, (), \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)) \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_EXPR(traits) \ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_55_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_55_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_55_(s, traits, \ - has_trailing_comma) \ - BOOST_CONTRACT_EXT_PP_BOOL_ASSERTION_TRAITS_EXPR(traits) \ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_55_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_55_(s, traits, 0, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_56) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_55_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_55_(s, traits, 0, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_56) - -#define BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_55_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_55_(s, traits, 1, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_56) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_55_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_55_(s, traits, 1, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_56) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_55_(s, traits, \ - is_static, next_assertion_macro) \ - BOOST_PP_EXPR_IIF(is_static, static) \ - if( \ - BOOST_PP_IIF( \ - BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND( \ - traits \ - ))) \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_56_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_56_ \ - )(s, BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND(traits), 0) \ - ) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)), \ - ( ) BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(next_assertion_macro, (), \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)) \ - else \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)), \ - ( ) BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(next_assertion_macro, (), \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)) - -// Extra parenthesis always internally added for if bool cond (so remove them). -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_55_(s, \ - cond_traits, has_trailing_comma) \ - BOOST_PP_TUPLE_REM_CTOR( BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_55_( \ - s, cond_traits, has_trailing_comma) ) - -#define BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_55_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_TYPE(traits)) \ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_ASSIGN(traits) \ - return \ - , - -// Implementation: OLDOF_..._OPERATOR internally splits tokens into a 2-tuple. -#define BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_55_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_TYPE(traits)) \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_ASSIGN(traits) \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_OPERATOR \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_EXPR(traits) \ - , - -/* PUBLIC (56) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_56( \ - s, assertions, assertion_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_56_(s, assertions, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_56_, assertion_traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_56( \ - s, assertions, assertion_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_56_(s, assertions, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_56_, assertion_traits) - -/* PRIVATE (56) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_56_( \ - s, assertions, assertion_macro, assertion_traits) \ - ( \ - BOOST_PP_TUPLE_REM_CTOR(assertions) \ - assertion_macro(s, assertion_traits) \ - ) - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_56_(s, traits) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_NAMESPACE_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_56_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_USING_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_56_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_TYPEDEF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_56_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_56_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_56_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_56_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_56_ \ - ))))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_56_(s, traits) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_RETURN_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_56_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_56_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_56_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_56_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_56_ \ - ))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_56_(s, traits) \ - namespace \ - (BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NEW_NAME(traits)) \ - as BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NAME(traits) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_56_(s, traits) \ - BOOST_PP_EXPR_IIF( \ - BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS( \ - traits \ - ) \ - )) \ - , \ - template \ - ) \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS(traits) \ - using \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAMESPACE(traits) \ - BOOST_PP_EXPR_IIF(BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits))), \ - (BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits)) as \ - ) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAME(traits)) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_56_(s, traits) \ - typedef \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NAME(traits)) \ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NEW_NAME(traits) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_56_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_56_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_56_(s, traits, \ - has_trailing_comma) \ - const \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)), \ - () BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(BOOST_CONTRACT_TEST_AUX_PP_CAPTURE_S_, (), \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)) \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_EXPR(traits) \ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_56_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_56_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_56_(s, traits, \ - has_trailing_comma) \ - BOOST_CONTRACT_EXT_PP_BOOL_ASSERTION_TRAITS_EXPR(traits) \ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_56_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_56_(s, traits, 0, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_57) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_56_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_56_(s, traits, 0, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_57) - -#define BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_56_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_56_(s, traits, 1, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_57) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_56_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_56_(s, traits, 1, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_57) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_56_(s, traits, \ - is_static, next_assertion_macro) \ - BOOST_PP_EXPR_IIF(is_static, static) \ - if( \ - BOOST_PP_IIF( \ - BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND( \ - traits \ - ))) \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_57_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_57_ \ - )(s, BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND(traits), 0) \ - ) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)), \ - ( ) BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(next_assertion_macro, (), \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)) \ - else \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)), \ - ( ) BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(next_assertion_macro, (), \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)) - -// Extra parenthesis always internally added for if bool cond (so remove them). -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_56_(s, \ - cond_traits, has_trailing_comma) \ - BOOST_PP_TUPLE_REM_CTOR( BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_56_( \ - s, cond_traits, has_trailing_comma) ) - -#define BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_56_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_TYPE(traits)) \ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_ASSIGN(traits) \ - return \ - , - -// Implementation: OLDOF_..._OPERATOR internally splits tokens into a 2-tuple. -#define BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_56_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_TYPE(traits)) \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_ASSIGN(traits) \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_OPERATOR \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_EXPR(traits) \ - , - -/* PUBLIC (57) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_57( \ - s, assertions, assertion_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_57_(s, assertions, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_57_, assertion_traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_57( \ - s, assertions, assertion_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_57_(s, assertions, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_57_, assertion_traits) - -/* PRIVATE (57) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_57_( \ - s, assertions, assertion_macro, assertion_traits) \ - ( \ - BOOST_PP_TUPLE_REM_CTOR(assertions) \ - assertion_macro(s, assertion_traits) \ - ) - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_57_(s, traits) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_NAMESPACE_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_57_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_USING_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_57_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_TYPEDEF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_57_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_57_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_57_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_57_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_57_ \ - ))))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_57_(s, traits) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_RETURN_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_57_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_57_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_57_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_57_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_57_ \ - ))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_57_(s, traits) \ - namespace \ - (BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NEW_NAME(traits)) \ - as BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NAME(traits) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_57_(s, traits) \ - BOOST_PP_EXPR_IIF( \ - BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS( \ - traits \ - ) \ - )) \ - , \ - template \ - ) \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS(traits) \ - using \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAMESPACE(traits) \ - BOOST_PP_EXPR_IIF(BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits))), \ - (BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits)) as \ - ) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAME(traits)) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_57_(s, traits) \ - typedef \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NAME(traits)) \ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NEW_NAME(traits) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_57_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_57_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_57_(s, traits, \ - has_trailing_comma) \ - const \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)), \ - () BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(BOOST_CONTRACT_TEST_AUX_PP_CAPTURE_S_, (), \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)) \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_EXPR(traits) \ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_57_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_57_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_57_(s, traits, \ - has_trailing_comma) \ - BOOST_CONTRACT_EXT_PP_BOOL_ASSERTION_TRAITS_EXPR(traits) \ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_57_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_57_(s, traits, 0, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_58) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_57_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_57_(s, traits, 0, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_58) - -#define BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_57_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_57_(s, traits, 1, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_58) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_57_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_57_(s, traits, 1, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_58) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_57_(s, traits, \ - is_static, next_assertion_macro) \ - BOOST_PP_EXPR_IIF(is_static, static) \ - if( \ - BOOST_PP_IIF( \ - BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND( \ - traits \ - ))) \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_58_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_58_ \ - )(s, BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND(traits), 0) \ - ) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)), \ - ( ) BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(next_assertion_macro, (), \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)) \ - else \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)), \ - ( ) BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(next_assertion_macro, (), \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)) - -// Extra parenthesis always internally added for if bool cond (so remove them). -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_57_(s, \ - cond_traits, has_trailing_comma) \ - BOOST_PP_TUPLE_REM_CTOR( BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_57_( \ - s, cond_traits, has_trailing_comma) ) - -#define BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_57_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_TYPE(traits)) \ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_ASSIGN(traits) \ - return \ - , - -// Implementation: OLDOF_..._OPERATOR internally splits tokens into a 2-tuple. -#define BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_57_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_TYPE(traits)) \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_ASSIGN(traits) \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_OPERATOR \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_EXPR(traits) \ - , - -/* PUBLIC (58) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_58( \ - s, assertions, assertion_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_58_(s, assertions, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_58_, assertion_traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_58( \ - s, assertions, assertion_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_58_(s, assertions, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_58_, assertion_traits) - -/* PRIVATE (58) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_58_( \ - s, assertions, assertion_macro, assertion_traits) \ - ( \ - BOOST_PP_TUPLE_REM_CTOR(assertions) \ - assertion_macro(s, assertion_traits) \ - ) - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_58_(s, traits) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_NAMESPACE_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_58_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_USING_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_58_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_TYPEDEF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_58_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_58_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_58_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_58_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_58_ \ - ))))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_58_(s, traits) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_RETURN_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_58_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_58_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_58_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_58_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_58_ \ - ))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_58_(s, traits) \ - namespace \ - (BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NEW_NAME(traits)) \ - as BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NAME(traits) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_58_(s, traits) \ - BOOST_PP_EXPR_IIF( \ - BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS( \ - traits \ - ) \ - )) \ - , \ - template \ - ) \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS(traits) \ - using \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAMESPACE(traits) \ - BOOST_PP_EXPR_IIF(BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits))), \ - (BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits)) as \ - ) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAME(traits)) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_58_(s, traits) \ - typedef \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NAME(traits)) \ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NEW_NAME(traits) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_58_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_58_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_58_(s, traits, \ - has_trailing_comma) \ - const \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)), \ - () BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(BOOST_CONTRACT_TEST_AUX_PP_CAPTURE_S_, (), \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)) \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_EXPR(traits) \ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_58_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_58_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_58_(s, traits, \ - has_trailing_comma) \ - BOOST_CONTRACT_EXT_PP_BOOL_ASSERTION_TRAITS_EXPR(traits) \ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_58_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_58_(s, traits, 0, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_59) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_58_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_58_(s, traits, 0, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_59) - -#define BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_58_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_58_(s, traits, 1, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_59) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_58_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_58_(s, traits, 1, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_59) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_58_(s, traits, \ - is_static, next_assertion_macro) \ - BOOST_PP_EXPR_IIF(is_static, static) \ - if( \ - BOOST_PP_IIF( \ - BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND( \ - traits \ - ))) \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_59_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_59_ \ - )(s, BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND(traits), 0) \ - ) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)), \ - ( ) BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(next_assertion_macro, (), \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)) \ - else \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)), \ - ( ) BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(next_assertion_macro, (), \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)) - -// Extra parenthesis always internally added for if bool cond (so remove them). -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_58_(s, \ - cond_traits, has_trailing_comma) \ - BOOST_PP_TUPLE_REM_CTOR( BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_58_( \ - s, cond_traits, has_trailing_comma) ) - -#define BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_58_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_TYPE(traits)) \ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_ASSIGN(traits) \ - return \ - , - -// Implementation: OLDOF_..._OPERATOR internally splits tokens into a 2-tuple. -#define BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_58_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_TYPE(traits)) \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_ASSIGN(traits) \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_OPERATOR \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_EXPR(traits) \ - , - -/* PUBLIC (59) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_59( \ - s, assertions, assertion_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_59_(s, assertions, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_59_, assertion_traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_59( \ - s, assertions, assertion_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_59_(s, assertions, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_59_, assertion_traits) - -/* PRIVATE (59) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_59_( \ - s, assertions, assertion_macro, assertion_traits) \ - ( \ - BOOST_PP_TUPLE_REM_CTOR(assertions) \ - assertion_macro(s, assertion_traits) \ - ) - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_59_(s, traits) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_NAMESPACE_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_59_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_USING_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_59_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_TYPEDEF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_59_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_59_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_59_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_59_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_59_ \ - ))))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_59_(s, traits) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_RETURN_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_59_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_59_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_59_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_59_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_59_ \ - ))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_59_(s, traits) \ - namespace \ - (BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NEW_NAME(traits)) \ - as BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NAME(traits) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_59_(s, traits) \ - BOOST_PP_EXPR_IIF( \ - BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS( \ - traits \ - ) \ - )) \ - , \ - template \ - ) \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS(traits) \ - using \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAMESPACE(traits) \ - BOOST_PP_EXPR_IIF(BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits))), \ - (BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits)) as \ - ) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAME(traits)) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_59_(s, traits) \ - typedef \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NAME(traits)) \ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NEW_NAME(traits) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_59_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_59_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_59_(s, traits, \ - has_trailing_comma) \ - const \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)), \ - () BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(BOOST_CONTRACT_TEST_AUX_PP_CAPTURE_S_, (), \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)) \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_EXPR(traits) \ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_59_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_59_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_59_(s, traits, \ - has_trailing_comma) \ - BOOST_CONTRACT_EXT_PP_BOOL_ASSERTION_TRAITS_EXPR(traits) \ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_59_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_59_(s, traits, 0, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_60) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_59_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_59_(s, traits, 0, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_60) - -#define BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_59_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_59_(s, traits, 1, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_60) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_59_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_59_(s, traits, 1, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_60) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_59_(s, traits, \ - is_static, next_assertion_macro) \ - BOOST_PP_EXPR_IIF(is_static, static) \ - if( \ - BOOST_PP_IIF( \ - BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND( \ - traits \ - ))) \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_60_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_60_ \ - )(s, BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND(traits), 0) \ - ) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)), \ - ( ) BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(next_assertion_macro, (), \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)) \ - else \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)), \ - ( ) BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(next_assertion_macro, (), \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)) - -// Extra parenthesis always internally added for if bool cond (so remove them). -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_59_(s, \ - cond_traits, has_trailing_comma) \ - BOOST_PP_TUPLE_REM_CTOR( BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_59_( \ - s, cond_traits, has_trailing_comma) ) - -#define BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_59_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_TYPE(traits)) \ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_ASSIGN(traits) \ - return \ - , - -// Implementation: OLDOF_..._OPERATOR internally splits tokens into a 2-tuple. -#define BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_59_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_TYPE(traits)) \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_ASSIGN(traits) \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_OPERATOR \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_EXPR(traits) \ - , - -/* PUBLIC (60) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_60( \ - s, assertions, assertion_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_60_(s, assertions, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_60_, assertion_traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_60( \ - s, assertions, assertion_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_60_(s, assertions, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_60_, assertion_traits) - -/* PRIVATE (60) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_60_( \ - s, assertions, assertion_macro, assertion_traits) \ - ( \ - BOOST_PP_TUPLE_REM_CTOR(assertions) \ - assertion_macro(s, assertion_traits) \ - ) - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_60_(s, traits) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_NAMESPACE_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_60_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_USING_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_60_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_TYPEDEF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_60_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_60_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_60_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_60_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_60_ \ - ))))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_60_(s, traits) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_RETURN_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_60_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_60_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_60_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_60_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_60_ \ - ))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_60_(s, traits) \ - namespace \ - (BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NEW_NAME(traits)) \ - as BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NAME(traits) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_60_(s, traits) \ - BOOST_PP_EXPR_IIF( \ - BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS( \ - traits \ - ) \ - )) \ - , \ - template \ - ) \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS(traits) \ - using \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAMESPACE(traits) \ - BOOST_PP_EXPR_IIF(BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits))), \ - (BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits)) as \ - ) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAME(traits)) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_60_(s, traits) \ - typedef \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NAME(traits)) \ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NEW_NAME(traits) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_60_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_60_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_60_(s, traits, \ - has_trailing_comma) \ - const \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)), \ - () BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(BOOST_CONTRACT_TEST_AUX_PP_CAPTURE_S_, (), \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)) \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_EXPR(traits) \ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_60_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_60_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_60_(s, traits, \ - has_trailing_comma) \ - BOOST_CONTRACT_EXT_PP_BOOL_ASSERTION_TRAITS_EXPR(traits) \ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_60_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_60_(s, traits, 0, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_61) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_60_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_60_(s, traits, 0, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_61) - -#define BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_60_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_60_(s, traits, 1, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_61) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_60_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_60_(s, traits, 1, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_61) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_60_(s, traits, \ - is_static, next_assertion_macro) \ - BOOST_PP_EXPR_IIF(is_static, static) \ - if( \ - BOOST_PP_IIF( \ - BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND( \ - traits \ - ))) \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_61_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_61_ \ - )(s, BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND(traits), 0) \ - ) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)), \ - ( ) BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(next_assertion_macro, (), \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)) \ - else \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)), \ - ( ) BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(next_assertion_macro, (), \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)) - -// Extra parenthesis always internally added for if bool cond (so remove them). -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_60_(s, \ - cond_traits, has_trailing_comma) \ - BOOST_PP_TUPLE_REM_CTOR( BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_60_( \ - s, cond_traits, has_trailing_comma) ) - -#define BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_60_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_TYPE(traits)) \ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_ASSIGN(traits) \ - return \ - , - -// Implementation: OLDOF_..._OPERATOR internally splits tokens into a 2-tuple. -#define BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_60_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_TYPE(traits)) \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_ASSIGN(traits) \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_OPERATOR \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_EXPR(traits) \ - , - -/* PUBLIC (61) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_61( \ - s, assertions, assertion_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_61_(s, assertions, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_61_, assertion_traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_61( \ - s, assertions, assertion_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_61_(s, assertions, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_61_, assertion_traits) - -/* PRIVATE (61) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_61_( \ - s, assertions, assertion_macro, assertion_traits) \ - ( \ - BOOST_PP_TUPLE_REM_CTOR(assertions) \ - assertion_macro(s, assertion_traits) \ - ) - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_61_(s, traits) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_NAMESPACE_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_61_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_USING_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_61_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_TYPEDEF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_61_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_61_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_61_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_61_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_61_ \ - ))))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_61_(s, traits) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_RETURN_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_61_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_61_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_61_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_61_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_61_ \ - ))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_61_(s, traits) \ - namespace \ - (BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NEW_NAME(traits)) \ - as BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NAME(traits) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_61_(s, traits) \ - BOOST_PP_EXPR_IIF( \ - BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS( \ - traits \ - ) \ - )) \ - , \ - template \ - ) \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS(traits) \ - using \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAMESPACE(traits) \ - BOOST_PP_EXPR_IIF(BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits))), \ - (BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits)) as \ - ) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAME(traits)) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_61_(s, traits) \ - typedef \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NAME(traits)) \ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NEW_NAME(traits) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_61_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_61_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_61_(s, traits, \ - has_trailing_comma) \ - const \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)), \ - () BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(BOOST_CONTRACT_TEST_AUX_PP_CAPTURE_S_, (), \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)) \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_EXPR(traits) \ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_61_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_61_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_61_(s, traits, \ - has_trailing_comma) \ - BOOST_CONTRACT_EXT_PP_BOOL_ASSERTION_TRAITS_EXPR(traits) \ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_61_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_61_(s, traits, 0, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_62) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_61_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_61_(s, traits, 0, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_62) - -#define BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_61_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_61_(s, traits, 1, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_62) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_61_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_61_(s, traits, 1, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_62) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_61_(s, traits, \ - is_static, next_assertion_macro) \ - BOOST_PP_EXPR_IIF(is_static, static) \ - if( \ - BOOST_PP_IIF( \ - BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND( \ - traits \ - ))) \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_62_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_62_ \ - )(s, BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND(traits), 0) \ - ) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)), \ - ( ) BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(next_assertion_macro, (), \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)) \ - else \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)), \ - ( ) BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(next_assertion_macro, (), \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)) - -// Extra parenthesis always internally added for if bool cond (so remove them). -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_61_(s, \ - cond_traits, has_trailing_comma) \ - BOOST_PP_TUPLE_REM_CTOR( BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_61_( \ - s, cond_traits, has_trailing_comma) ) - -#define BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_61_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_TYPE(traits)) \ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_ASSIGN(traits) \ - return \ - , - -// Implementation: OLDOF_..._OPERATOR internally splits tokens into a 2-tuple. -#define BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_61_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_TYPE(traits)) \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_ASSIGN(traits) \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_OPERATOR \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_EXPR(traits) \ - , - -/* PUBLIC (62) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_62( \ - s, assertions, assertion_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_62_(s, assertions, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_62_, assertion_traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_62( \ - s, assertions, assertion_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_62_(s, assertions, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_62_, assertion_traits) - -/* PRIVATE (62) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_62_( \ - s, assertions, assertion_macro, assertion_traits) \ - ( \ - BOOST_PP_TUPLE_REM_CTOR(assertions) \ - assertion_macro(s, assertion_traits) \ - ) - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_62_(s, traits) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_NAMESPACE_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_62_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_USING_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_62_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_TYPEDEF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_62_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_62_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_62_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_62_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_62_ \ - ))))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_62_(s, traits) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_RETURN_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_62_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_62_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_62_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_62_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_62_ \ - ))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_62_(s, traits) \ - namespace \ - (BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NEW_NAME(traits)) \ - as BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NAME(traits) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_62_(s, traits) \ - BOOST_PP_EXPR_IIF( \ - BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS( \ - traits \ - ) \ - )) \ - , \ - template \ - ) \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS(traits) \ - using \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAMESPACE(traits) \ - BOOST_PP_EXPR_IIF(BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits))), \ - (BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits)) as \ - ) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAME(traits)) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_62_(s, traits) \ - typedef \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NAME(traits)) \ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NEW_NAME(traits) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_62_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_62_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_62_(s, traits, \ - has_trailing_comma) \ - const \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)), \ - () BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(BOOST_CONTRACT_TEST_AUX_PP_CAPTURE_S_, (), \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)) \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_EXPR(traits) \ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_62_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_62_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_62_(s, traits, \ - has_trailing_comma) \ - BOOST_CONTRACT_EXT_PP_BOOL_ASSERTION_TRAITS_EXPR(traits) \ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_62_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_62_(s, traits, 0, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_63) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_62_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_62_(s, traits, 0, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_63) - -#define BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_62_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_62_(s, traits, 1, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_63) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_62_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_62_(s, traits, 1, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_63) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_62_(s, traits, \ - is_static, next_assertion_macro) \ - BOOST_PP_EXPR_IIF(is_static, static) \ - if( \ - BOOST_PP_IIF( \ - BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND( \ - traits \ - ))) \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_63_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_63_ \ - )(s, BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND(traits), 0) \ - ) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)), \ - ( ) BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(next_assertion_macro, (), \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)) \ - else \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)), \ - ( ) BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(next_assertion_macro, (), \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)) - -// Extra parenthesis always internally added for if bool cond (so remove them). -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_62_(s, \ - cond_traits, has_trailing_comma) \ - BOOST_PP_TUPLE_REM_CTOR( BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_62_( \ - s, cond_traits, has_trailing_comma) ) - -#define BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_62_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_TYPE(traits)) \ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_ASSIGN(traits) \ - return \ - , - -// Implementation: OLDOF_..._OPERATOR internally splits tokens into a 2-tuple. -#define BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_62_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_TYPE(traits)) \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_ASSIGN(traits) \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_OPERATOR \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_EXPR(traits) \ - , - -/* PUBLIC (63) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_63( \ - s, assertions, assertion_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_63_(s, assertions, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_63_, assertion_traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_63( \ - s, assertions, assertion_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_63_(s, assertions, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_63_, assertion_traits) - -/* PRIVATE (63) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_63_( \ - s, assertions, assertion_macro, assertion_traits) \ - ( \ - BOOST_PP_TUPLE_REM_CTOR(assertions) \ - assertion_macro(s, assertion_traits) \ - ) - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_63_(s, traits) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_NAMESPACE_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_63_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_USING_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_63_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_TYPEDEF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_63_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_63_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_63_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_63_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_63_ \ - ))))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_63_(s, traits) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_RETURN_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_63_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_63_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_63_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_63_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_63_ \ - ))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_63_(s, traits) \ - namespace \ - (BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NEW_NAME(traits)) \ - as BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NAME(traits) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_63_(s, traits) \ - BOOST_PP_EXPR_IIF( \ - BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS( \ - traits \ - ) \ - )) \ - , \ - template \ - ) \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS(traits) \ - using \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAMESPACE(traits) \ - BOOST_PP_EXPR_IIF(BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits))), \ - (BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits)) as \ - ) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAME(traits)) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_63_(s, traits) \ - typedef \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NAME(traits)) \ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NEW_NAME(traits) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_63_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_63_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_63_(s, traits, \ - has_trailing_comma) \ - const \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)), \ - () BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(BOOST_CONTRACT_TEST_AUX_PP_CAPTURE_S_, (), \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)) \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_EXPR(traits) \ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_63_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_63_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_63_(s, traits, \ - has_trailing_comma) \ - BOOST_CONTRACT_EXT_PP_BOOL_ASSERTION_TRAITS_EXPR(traits) \ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_63_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_63_(s, traits, 0, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_64) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_63_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_63_(s, traits, 0, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_64) - -#define BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_63_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_63_(s, traits, 1, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_64) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_63_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_63_(s, traits, 1, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_64) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_63_(s, traits, \ - is_static, next_assertion_macro) \ - BOOST_PP_EXPR_IIF(is_static, static) \ - if( \ - BOOST_PP_IIF( \ - BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND( \ - traits \ - ))) \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_64_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_64_ \ - )(s, BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND(traits), 0) \ - ) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)), \ - ( ) BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(next_assertion_macro, (), \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)) \ - else \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)), \ - ( ) BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(next_assertion_macro, (), \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)) - -// Extra parenthesis always internally added for if bool cond (so remove them). -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_63_(s, \ - cond_traits, has_trailing_comma) \ - BOOST_PP_TUPLE_REM_CTOR( BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_63_( \ - s, cond_traits, has_trailing_comma) ) - -#define BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_63_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_TYPE(traits)) \ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_ASSIGN(traits) \ - return \ - , - -// Implementation: OLDOF_..._OPERATOR internally splits tokens into a 2-tuple. -#define BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_63_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_TYPE(traits)) \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_ASSIGN(traits) \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_OPERATOR \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_EXPR(traits) \ - , - -/* PUBLIC (64) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_64( \ - s, assertions, assertion_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_64_(s, assertions, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_64_, assertion_traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_64( \ - s, assertions, assertion_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_64_(s, assertions, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_64_, assertion_traits) - -/* PRIVATE (64) */ - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_64_( \ - s, assertions, assertion_macro, assertion_traits) \ - ( \ - BOOST_PP_TUPLE_REM_CTOR(assertions) \ - assertion_macro(s, assertion_traits) \ - ) - -#define BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_64_(s, traits) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_NAMESPACE_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_64_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_USING_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_64_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_TYPEDEF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_64_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_64_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_64_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_64_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_64_ \ - ))))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTION_S_64_(s, traits) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_RETURN_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_64_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_64_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_IF_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_64_ \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_STATIC_IF_ASSERTION_TRAITS_IS( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY(traits)), \ - BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_64_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTION_S_64_ \ - ))))(s, traits) - -#define BOOST_CONTRACT_TEST_AUX_PP_NAMESPACE_ASSERTION_S_64_(s, traits) \ - namespace \ - (BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NEW_NAME(traits)) \ - as BOOST_CONTRACT_EXT_PP_NAMESPACE_ASSERTION_TRAITS_NAME(traits) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_USING_ASSERTION_S_64_(s, traits) \ - BOOST_PP_EXPR_IIF( \ - BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS( \ - traits \ - ) \ - )) \ - , \ - template \ - ) \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_TEMPLATE_PARAMS(traits) \ - using \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAMESPACE(traits) \ - BOOST_PP_EXPR_IIF(BOOST_PP_COMPL(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits))), \ - (BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NEW_NAME(traits)) as \ - ) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_USING_ASSERTION_TRAITS_NAME(traits)) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_TYPEDEF_ASSERTION_S_64_(s, traits) \ - typedef \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NAME(traits)) \ - BOOST_CONTRACT_EXT_PP_TYPEDEF_ASSERTION_TRAITS_NEW_NAME(traits) \ - , - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_S_64_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_64_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_64_(s, traits, \ - has_trailing_comma) \ - const \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)), \ - () BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(BOOST_CONTRACT_TEST_AUX_PP_CAPTURE_S_, (), \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_CAPTURES(traits)) \ - BOOST_CONTRACT_EXT_PP_CONST_ASSERTION_TRAITS_EXPR(traits) \ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_S_64_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_64_(s, traits, 1) - -#define BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_64_(s, traits, \ - has_trailing_comma) \ - BOOST_CONTRACT_EXT_PP_BOOL_ASSERTION_TRAITS_EXPR(traits) \ - BOOST_PP_COMMA_IF(has_trailing_comma) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_S_64_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_64_(s, traits, 0, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_65) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_IF_ASSERTION_S_64_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_64_(s, traits, 0, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_65) - -#define BOOST_CONTRACT_TEST_AUX_PP_STATIC_IF_ASSERTION_S_64_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_64_(s, traits, 1, \ - BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_65) - -#define BOOST_CONTRACT_TEST_AUX_PP_POST_STATIC_IF_ASSERTION_S_64_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_64_(s, traits, 1, \ - BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_65) - -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_IMPL_S_64_(s, traits, \ - is_static, next_assertion_macro) \ - BOOST_PP_EXPR_IIF(is_static, static) \ - if( \ - BOOST_PP_IIF( \ - BOOST_CONTRACT_EXT_PP_KEYWORD_IS_CONST_FRONT( \ - BOOST_CONTRACT_EXT_PP_ASSERTION_TRAITS_KEY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND( \ - traits \ - ))) \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_CONST_ASSERTION_IMPL_S_65_ \ - , \ - BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_65_ \ - )(s, BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_COND(traits), 0) \ - ) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)), \ - ( ) BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(next_assertion_macro, (), \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_THENS(traits)) \ - else \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)), \ - ( ) BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT_ ## s \ - )(next_assertion_macro, (), \ - BOOST_CONTRACT_EXT_PP_IF_ASSERTION_TRAITS_ELSES(traits)) - -// Extra parenthesis always internally added for if bool cond (so remove them). -#define BOOST_CONTRACT_TEST_AUX_PP_IF_ASSERTION_BOOL_COND_S_64_(s, \ - cond_traits, has_trailing_comma) \ - BOOST_PP_TUPLE_REM_CTOR( BOOST_CONTRACT_TEST_AUX_PP_BOOL_ASSERTION_IMPL_S_64_( \ - s, cond_traits, has_trailing_comma) ) - -#define BOOST_CONTRACT_TEST_AUX_PP_RETURN_ASSERTION_S_64_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_TYPE(traits)) \ - BOOST_CONTRACT_EXT_PP_RETURN_ASSERTION_TRAITS_ASSIGN(traits) \ - return \ - , - -// Implementation: OLDOF_..._OPERATOR internally splits tokens into a 2-tuple. -#define BOOST_CONTRACT_TEST_AUX_PP_OLDOF_ASSERTION_S_64_(s, traits) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_TYPE(traits)) \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_ASSIGN(traits) \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_OPERATOR \ - BOOST_CONTRACT_EXT_PP_OLDOF_ASSERTION_TRAITS_EXPR(traits) \ - , - -#endif // #include guard diff --git a/test/aux_/pp_template.hpp b/test/aux_/pp_template.hpp deleted file mode 100644 index 863cccf..0000000 --- a/test/aux_/pp_template.hpp +++ /dev/null @@ -1,174 +0,0 @@ - -#ifndef BOOST_CONTRACT_TEST_AUX_PP_TEMPLATE_HPP_ -#define BOOST_CONTRACT_TEST_AUX_PP_TEMPLATE_HPP_ - -#include "pp_1tuple_rem.hpp" -#include -#include -#include -#include -#include -#include -#include -#include - -#ifndef BOOST_CONTRACT_TEST_AUX_PP_TEMPLATE_CHECK -# error "must #define BOOST_CONTRACT_TEST_AUX_PP_TEMPLATE_CHECK macro" -#endif - -/* PUBLIC */ - -#define BOOST_CONTRACT_TEST_AUX_PP_TEMPLATE(template_, template_params) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY(template_), \ - BOOST_PP_TUPLE_EAT(1) \ - , \ - template BOOST_CONTRACT_TEST_AUX_PP_TEMPLATE_PARAMS_ \ - )(template_params) - -/* PRIVATE */ - -#define BOOST_CONTRACT_TEST_AUX_PP_TEMPLATE_PARAMS_(template_params) \ - ( \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY(template_params), \ - BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOR_EACH_I \ - )(BOOST_CONTRACT_TEST_AUX_PP_TEMPLATE_PARAM_, ~, template_params) \ - ) - -#define BOOST_CONTRACT_TEST_AUX_PP_TEMPLATE_PARAM_( \ - r, unused, i, template_param) \ - BOOST_PP_COMMA_IF(i) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_HAS_PAREN( \ - BOOST_CONTRACT_EXT_PP_PARAM_TRAITS_TYPE(template_param)), \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM \ - , \ - BOOST_PP_TUPLE_REM(1) \ - )(BOOST_CONTRACT_EXT_PP_PARAM_TRAITS_TYPE(template_param)) \ - BOOST_CONTRACT_EXT_PP_PARAM_TRAITS_NAME(template_param) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_PARAM_TRAITS_DEFAULT(template_param)), \ - BOOST_PP_TUPLE_EAT(2) \ - , \ - BOOST_PP_TUPLE_REM(2) \ - )( \ - BOOST_PP_EMPTY(), \ - default BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_PARAM_TRAITS_DEFAULT(template_param)) \ - ) - -/* CODE */ - -namespace boost { namespace contract { namespace test { namespace aux { - -void pp_template ( ) { - // Test no template. - BOOST_CONTRACT_TEST_AUX_PP_TEMPLATE_CHECK( BOOST_PP_EMPTY() ) - - // Test template with no parameter. - BOOST_CONTRACT_TEST_AUX_PP_TEMPLATE_CHECK( template( ) ) - - // Test named typename. - BOOST_CONTRACT_TEST_AUX_PP_TEMPLATE_CHECK( template( typename T ) ) - // Test named typename with default. - BOOST_CONTRACT_TEST_AUX_PP_TEMPLATE_CHECK( - template( typename T, default (std::map) ) ) - // Test named variadic typename. - BOOST_CONTRACT_TEST_AUX_PP_TEMPLATE_CHECK( template( typename... T) ) - // Test unnamed typename. - BOOST_CONTRACT_TEST_AUX_PP_TEMPLATE_CHECK( template( typename ) ) - // Test unnamed typename with default. - BOOST_CONTRACT_TEST_AUX_PP_TEMPLATE_CHECK( - template( typename, default (std::map) ) ) - // Test unnamed variadic typename. - BOOST_CONTRACT_TEST_AUX_PP_TEMPLATE_CHECK( template( typename... ) ) - - // Test named class. - BOOST_CONTRACT_TEST_AUX_PP_TEMPLATE_CHECK( template( class T ) ) - // Test named class with default. - BOOST_CONTRACT_TEST_AUX_PP_TEMPLATE_CHECK( - template( class T, default (std::map) ) ) - // Test named variadic class. - BOOST_CONTRACT_TEST_AUX_PP_TEMPLATE_CHECK( template( class... T) ) - // Test unnamed class. - BOOST_CONTRACT_TEST_AUX_PP_TEMPLATE_CHECK( template( class ) ) - // Test unnamed class with default. - BOOST_CONTRACT_TEST_AUX_PP_TEMPLATE_CHECK( - template( class, default (std::map) ) ) - // Test unnamed variadic class. - BOOST_CONTRACT_TEST_AUX_PP_TEMPLATE_CHECK( template( class... ) ) - - // Test named value. - BOOST_CONTRACT_TEST_AUX_PP_TEMPLATE_CHECK( template( int I ) ) - // Test named value with default. - BOOST_CONTRACT_TEST_AUX_PP_TEMPLATE_CHECK( template( int I, default 123 ) ) - // Test unnamed value. - BOOST_CONTRACT_TEST_AUX_PP_TEMPLATE_CHECK( template( int ) ) - // Test unnamed value with default. - BOOST_CONTRACT_TEST_AUX_PP_TEMPLATE_CHECK( template( int, default 123 ) ) - - // Test named value (of parenthesized type). - BOOST_CONTRACT_TEST_AUX_PP_TEMPLATE_CHECK( - template( (std::map::key_type) I ) ) - // Test named value (of parenthesized type) with default. - BOOST_CONTRACT_TEST_AUX_PP_TEMPLATE_CHECK( - template( (std::map::key_type) I, default 123 ) ) - // Test unnamed value (of parenthesized type). - BOOST_CONTRACT_TEST_AUX_PP_TEMPLATE_CHECK( - template( (std::map::key_type) ) ) - // Test unnamed value (of parenthesized type) with default. - BOOST_CONTRACT_TEST_AUX_PP_TEMPLATE_CHECK( - template( (std::map::key_type), default 123 ) ) - - // Test template-template parameter with no parameters. - BOOST_CONTRACT_TEST_AUX_PP_TEMPLATE_CHECK( template( template( ) class P ) ) - // Test template-template parameter with parameters. - BOOST_CONTRACT_TEST_AUX_PP_TEMPLATE_CHECK( - template( - template( - typename T, - class C, - std::map::key_type I, - typename... V - ) class P - ) - ) - // Test template-template parameter with defaults. - BOOST_CONTRACT_TEST_AUX_PP_TEMPLATE_CHECK( - template( - template( - typename T = std::map::key_type, - class C = std::map::key_type, - std::map::key_type I = 123, - typename... V - ) class P, default (::n::c::template t) - ) - ) - // Test template-template parameter with unnamed parameters. - BOOST_CONTRACT_TEST_AUX_PP_TEMPLATE_CHECK( - template( - template( - typename, - class, - std::map::key_type, - typename... - ) class - ) - ) - // Test template-template parameter with unnamed and defaults. - BOOST_CONTRACT_TEST_AUX_PP_TEMPLATE_CHECK( - template( - template( - typename = std::map::key_type, - class = std::map::key_type, - std::map::key_type = 123, - typename... - ) class, default (::n::c::template t) - ) - ) -} - -} } } } // namespace - -#endif // #include guard - diff --git a/test/aux_/pp_traits.hpp b/test/aux_/pp_traits.hpp deleted file mode 100644 index 691c45d..0000000 --- a/test/aux_/pp_traits.hpp +++ /dev/null @@ -1,144 +0,0 @@ - -#ifndef BOOST_CONTRACT_TEST_AUX_PP_TRAITS_HPP_ -#define BOOST_CONTRACT_TEST_AUX_PP_TRAITS_HPP_ - -#include -#include -#include -#include -#include -#include -#include -#include - -/* PUBLIC */ - -// Precondition: #define BOOST_CONTRACT_EXT_PP_..._TRAITS_TEST_AT_ to the INDEX -// of the trait that needs to be tested. -#ifndef DEBUG -# define BOOST_CONTRACT_TEST_AUX_PP_TRAITS( \ - traits_elem_macro, \ - traits_parse_macro, \ - decl_before_trait, \ - decl_at_trait, \ - decl_after_trait, \ - parsed_trait \ - ) \ - BOOST_CONTRACT_TEST_AUX_PP_TRAITS_( \ - BOOST_CONTRACT_EXT_PP_DECL_TRAITS_AUX_DONE(traits_parse_macro(1, \ - decl_before_trait decl_at_trait decl_after_trait)), \ - traits_elem_macro, \ - parsed_trait, \ - decl_after_trait \ - ) -#else -// To #define DEBUG is useful when looking at pre-processed output (the NIL -// leading parsed_traits will be remove by non-debug invocation of DONE). -# define BOOST_CONTRACT_TEST_AUX_PP_TRAITS( \ - traits_elem_macro, \ - traits_parse_macro, \ - decl_before_trait, \ - decl_at_trait, \ - decl_after_trait, \ - parsed_trait \ - ) \ - "NOTE: #undefine DEBUG macro (e.g., `bjam cxxflags=-UDEBUG ...`) to complete generation of C++ code" \ - decl = decl_before_trait decl_at_trait decl_after_trait \ - --> \ - (remaining_decl BOOST_PP_NIL, (BOOST_PP_NIL) parsed_traits) = \ - traits_parse_macro(1, \ - decl_before_trait decl_at_trait decl_after_trait) -#endif - -#define BOOST_CONTRACT_TEST_AUX_PP_TRAITS_REPORT_ERRORS \ - boost::report_errors() - -/* PRIVATE */ - -#define BOOST_CONTRACT_TEST_AUX_PP_TRAITS_( \ - decl_traits, traits_elem_macro, parsed_trait, decl_after_trait) \ - BOOST_CONTRACT_TEST_AUX_PP_TRAITS_EQUAL_( \ - traits_elem_macro(BOOST_PP_TUPLE_ELEM(2, 1, decl_traits)), \ - parsed_trait \ - ) \ - BOOST_CONTRACT_TEST_AUX_PP_TRAITS_EQUAL_( \ - BOOST_CONTRACT_EXT_PP_NIL_REMOVE_BACK( \ - BOOST_PP_TUPLE_ELEM(2, 0, decl_traits)), \ - decl_after_trait \ - ) - -#define BOOST_CONTRACT_TEST_AUX_PP_TRAITS_EQUAL_(left, right) \ - BOOST_CONTRACT_TEST_AUX_PP_TRAITS_TEST_( \ - boost::contract::test::aux::pp_traits_::equal( \ - boost::contract::test::aux::pp_traits_::trim( \ - BOOST_CONTRACT_EXT_PP_STRINGIZE(left BOOST_PP_EMPTY()) \ - ) \ - , \ - boost::contract::test::aux::pp_traits_::trim( \ - BOOST_CONTRACT_EXT_PP_STRINGIZE(right BOOST_PP_EMPTY()) \ - ) \ - ) \ - ) - -// Indirection needed for proper expansion of BOOST_TEST's error message. -#define BOOST_CONTRACT_TEST_AUX_PP_TRAITS_TEST_(pred) \ - BOOST_CONTRACT_TEST_AUX_PP_TRAITS_TEST_2ND_(pred) - -#define BOOST_CONTRACT_TEST_AUX_PP_TRAITS_TEST_2ND_(pred) BOOST_TEST(pred); - -namespace boost { namespace contract { namespace test { namespace aux { - namespace pp_traits_ { - -// Compare strings for equality printing informational message if they differ. -bool equal ( std::string const& left, std::string const& right ) { - std::string::size_type l = 0, r = 0; - while(l < left.size() && r < right.size()) { - if(left[l] != right[r]) break; - ++l; - ++r; - } - if(l != left.size() || r != right.size()) { - std::cerr << - std::endl << - "error: following strings differ at characters '" << - left[l] << "' '" << right[r] << - "' (positions indented below)" << std::endl << - std::endl << - left.substr(0, l) << std::endl << - std::string(l, ' ') + left.substr(l, left.size() - 1) << - std::endl << - right.substr(0, r) << std::endl << - std::string(r, ' ') + right.substr(r, right.size() - 1) << - std::endl << - std::endl - ; - return false; - } - return true; -} - -// Remove spaces not separating words, etc. -std::string trim ( std::string const& source ) { - std::locale locale; - std::string result = ""; - for(std::string::size_type i = 0; i < source.size(); ++i) { - if(source[i] != ' ') { - result += source[i]; // Keep non-space char. - } else if(i == 0) { - // Skip leading space. - } else if(i == source.size() - 1) { - // Skip trailing space. - } else if(!std::isalpha(source[i - 1], locale) || - !std::isalpha(source[i + 1], locale)) { - // Skip spaces not in between letters. - } else { - result += source[i]; // Keep separation space. - } - } - return result; -} - -} } } } } // namespace - -#endif // #include guard - diff --git a/test/aux_/pp_verbatim.hpp b/test/aux_/pp_verbatim.hpp deleted file mode 100644 index 521cb15..0000000 --- a/test/aux_/pp_verbatim.hpp +++ /dev/null @@ -1,49 +0,0 @@ - -#ifndef BOOST_CONTRACT_TEST_AUX_PP_VERBATIM_HPP_ -#define BOOST_CONTRACT_TEST_AUX_PP_VERBATIM_HPP_ - -#include - -#ifndef BOOST_CONTRACT_TEST_AUX_PP_VERBATIM_CHECK -# error "must #define BOOST_CONTRACT_TEST_AUX_PP_VERBATIM_CHECK macro" -#endif - -namespace boost { namespace contract { namespace test { namespace aux { - -void pp_verbatim ( ) { - // Test no attributes (for all C++11, MSVC, GCC, etc). - BOOST_CONTRACT_TEST_AUX_PP_VERBATIM_CHECK( BOOST_PP_EMPTY() ) - - // Test C++11 attributes with commas. - BOOST_CONTRACT_TEST_AUX_PP_VERBATIM_CHECK( - verbatim([[noreturn, deprecated("reason")]]) ) - // Test multiple C++11 attributes. - BOOST_CONTRACT_TEST_AUX_PP_VERBATIM_CHECK( - verbatim([[noreturn]] [[deprecated("reason")]]) ) - // Test single C++11 attribute. - BOOST_CONTRACT_TEST_AUX_PP_VERBATIM_CHECK( verbatim([[export]]) ) - - // NOTE: MSVC declaration specifications do not allow for commas. - // Test multiple MSVC declaration specifications. - BOOST_CONTRACT_TEST_AUX_PP_VERBATIM_CHECK( - verbatim(__declspec(noreturn) __declspec(deprecated("reason"))) ) - // Test single MSVC declaration specification. - BOOST_CONTRACT_TEST_AUX_PP_VERBATIM_CHECK( verbatim(__declspec(dllexport)) ) - - // NOTE: GCC attributes do not allow for commas. - // Test multiple GCC attributes. - BOOST_CONTRACT_TEST_AUX_PP_VERBATIM_CHECK( - verbatim( - __attribute__((noreturn)) - __attribute__((deprecated("reason"))) - ) - ) - // Test single GCC attribute. - BOOST_CONTRACT_TEST_AUX_PP_VERBATIM_CHECK( - verbatim(__attribute__((dllexport))) ) -} - -} } } } // namespace - -#endif // #include guard - diff --git a/test/base_types.cpp b/test/base_types.cpp new file mode 100644 index 0000000..3366d85 --- /dev/null +++ b/test/base_types.cpp @@ -0,0 +1,62 @@ + +#include +#include +#include +#include + +struct A; struct AA; +struct X; struct XX; +struct U; struct UU; + +template struct a2; +template struct x2; +template struct u2; + +struct a0; +struct x0; +struct u0; + +int main() { + typedef BOOST_CONTRACT_BASE_TYPES( + public a2 + , private b2 + , protected c2 + + , virtual public x2 + , virtual private y2 + , virtual protected z2 + + , public virtual u2 + , private virtual v2 + , protected virtual w2 + ) base_types2; + BOOST_TEST((boost::is_same, x2, u2 > + >::value)); + + typedef BOOST_CONTRACT_BASE_TYPES( + private b1 + , protected c1 + + , virtual private y1 + , virtual protected z1 + + , private virtual v1 + , protected virtual w1 + ) base_types1; + BOOST_TEST((boost::is_same + >::value)); + + typedef BOOST_CONTRACT_BASE_TYPES( + public a0 + , virtual public x0 + , public virtual u0 + ) base_types0; + BOOST_TEST((boost::is_same + >::value)); + + return boost::report_errors(); +} + diff --git a/test/constructor_bases.cpp b/test/constructor_bases.cpp new file mode 100644 index 0000000..b1e8366 --- /dev/null +++ b/test/constructor_bases.cpp @@ -0,0 +1,181 @@ + +#include "aux_/oteststream.hpp" +#include +#include +#include +#include +#include + +// Test constructor contracts for classes with and without bases. + +boost::contract::aux::test::oteststream out; + +struct d +# define BASES private boost::contract::constructor_precondition + : BASES +{ + typedef BOOST_CONTRACT_BASE_TYPES(BASES) base_types; +# undef BASES + + void invariant() const { + out << "d::inv" << std::endl; + } + + static void static_invariant() { + out << "d::static_inv" << std::endl; + } + + explicit d(unsigned const) : + boost::contract::constructor_precondition([&] { + out << "d::ctor::pre" << std::endl; + }) + { + boost::contract::type c = boost::contract::constructor(this) + .postcondition([&] { + out << "d::ctor::post" << std::endl; + }) + ; + out << "d::ctor::body" << std::endl; + } +}; + +struct c +# define BASES private boost::contract::constructor_precondition, \ + public d + : BASES +{ + typedef BOOST_CONTRACT_BASE_TYPES(BASES) base_types; +# undef BASES + + void invariant() const { + out << "c::inv" << std::endl; + } + + static void static_invariant() { + out << "c::static_inv" << std::endl; + } + + explicit c(unsigned const x) : + boost::contract::constructor_precondition([&] { + out << "c::ctor::pre" << std::endl; + }), + d(x) + { + boost::contract::type c = boost::contract::constructor(this) + .postcondition([&] { + out << "c::ctor::post" << std::endl; + }) + ; + out << "c::ctor::body" << std::endl; + } +}; + +struct b +# define BASES private boost::contract::constructor_precondition + : BASES +{ + typedef BOOST_CONTRACT_BASE_TYPES(BASES) base_types; +# undef BASES + + void invariant() const { + out << "b::inv" << std::endl; + } + + static void static_invariant() { + out << "b::static_inv" << std::endl; + } + + explicit b(unsigned const) : + boost::contract::constructor_precondition([&] { + out << "b::ctor::pre" << std::endl; + }) + { + boost::contract::type c = boost::contract::constructor(this) + .postcondition([&] { + out << "b::ctor::post" << std::endl; + }) + ; + out << "b::ctor::body" << std::endl; + } +}; + +struct a +# define BASES private boost::contract::constructor_precondition, \ + public b, public c + : BASES +{ + typedef BOOST_CONTRACT_BASE_TYPES(BASES) base_types; +# undef BASES + + void invariant() const { + out << "a::inv" << std::endl; + BOOST_CONTRACT_ASSERT(value > 0); + } + + static void static_invariant() { + out << "a::static_inv" << std::endl; + } + + explicit a(unsigned const x) : + boost::contract::constructor_precondition([&] { + out << "a::ctor::pre" << std::endl; + BOOST_CONTRACT_ASSERT(x > 0); + }), + b(x), + c(x), + value(x) + { + boost::contract::type c = boost::contract::constructor(this) + .postcondition([&] { + out << "a::ctor::post" << std::endl; + BOOST_CONTRACT_ASSERT(this->value == x); + }) + ; + out << "a::ctor::body" << std::endl; + } + + unsigned value; +}; + +int main() { + std::ostringstream ok; + + out.str(""); + a aa(123); + ok.str(""); + ok + << "a::ctor::pre" << std::endl + + << "b::ctor::pre" << std::endl + << "b::static_inv" << std::endl + << "b::ctor::body" << std::endl + << "b::static_inv" << std::endl + << "b::inv" << std::endl + << "b::ctor::post" << std::endl + + << "c::ctor::pre" << std::endl + + << "d::ctor::pre" << std::endl + << "d::static_inv" << std::endl + << "d::ctor::body" << std::endl + << "d::static_inv" << std::endl + << "d::inv" << std::endl + << "d::ctor::post" << std::endl + + << "c::static_inv" << std::endl + << "c::ctor::body" << std::endl + << "c::static_inv" << std::endl + << "c::inv" << std::endl + << "c::ctor::post" << std::endl + + << "a::static_inv" << std::endl + << "a::ctor::body" << std::endl + << "a::static_inv" << std::endl + << "a::inv" << std::endl + << "a::ctor::post" << std::endl + ; + BOOST_TEST(out.check(ok.str())); + + return boost::report_errors(); +} + diff --git a/test/destructor_bases.cpp b/test/destructor_bases.cpp new file mode 100644 index 0000000..682d7b7 --- /dev/null +++ b/test/destructor_bases.cpp @@ -0,0 +1,134 @@ + +#include "aux_/oteststream.hpp" +#include +#include +#include +#include +#include + +// Test destructor contracts for classes with and without bases. + +boost::contract::aux::test::oteststream out; + +struct d { // Test inheritance level 0. + void invariant() const { + out << "d::inv" << std::endl; + } + + static void static_invariant() { + out << "d::static_inv" << std::endl; + } + + ~d() { + boost::contract::type c = boost::contract::destructor(this) + .postcondition([&] () { + out << "d::dtor::post" << std::endl; + }) + ; + out << "d::dtor::body" << std::endl; + } +}; + +struct c // Test inheritance level 1. + #define BASES public d + : BASES +{ + typedef BOOST_CONTRACT_BASE_TYPES(BASES) base_types; + #undef BASES + + void invariant() const { + out << "c::inv" << std::endl; + } + + static void static_invariant() { + out << "c::static_inv" << std::endl; + } + + ~c() { + boost::contract::type c = boost::contract::destructor(this) + .postcondition([&] () { + out << "c::dtor::post" << std::endl; + }) + ; + out << "c::dtor::body" << std::endl; + } +}; + +struct b { // Test inheritance level 0. + void invariant() const { + out << "b::inv" << std::endl; + } + + static void static_invariant() { + out << "b::static_inv" << std::endl; + } + + ~b() { + boost::contract::type c = boost::contract::destructor(this) + .postcondition([&] () { + out << "b::dtor::post" << std::endl; + }) + ; + out << "b::dtor::body" << std::endl; + } +}; + +struct a // Test multiple inheritance and inheritance level 2. + #define BASES public b, public c + : BASES +{ + typedef BOOST_CONTRACT_BASE_TYPES(BASES) base_types; + #undef BASES + + void invariant() const { + out << "a::inv" << std::endl; + } + + static void static_invariant() { + out << "a::static_inv" << std::endl; + } + + ~a() { + boost::contract::type c = boost::contract::destructor(this) + .postcondition([&] () { + out << "a::dtor::post" << std::endl; + }) + ; + out << "a::dtor::body" << std::endl; + } +}; + +int main() { + std::ostringstream ok; + + { + a aa; + out.str(""); + } // `a`'s destructor called, and `out` set, here. + ok.str(""); + ok + << "a::static_inv" << std::endl + << "a::dtor::body" << std::endl + << "a::static_inv" << std::endl + << "a::dtor::post" << std::endl + + << "c::static_inv" << std::endl + << "c::dtor::body" << std::endl + << "c::static_inv" << std::endl + << "c::dtor::post" << std::endl + + << "d::static_inv" << std::endl + << "d::dtor::body" << std::endl + << "d::static_inv" << std::endl + << "d::dtor::post" << std::endl + + << "b::static_inv" << std::endl + << "b::dtor::body" << std::endl + << "b::static_inv" << std::endl + << "b::dtor::post" << std::endl + ; + BOOST_TEST(out.check(ok.str())); + + return boost::report_errors(); +} + diff --git a/test/has_bases.cpp b/test/has_bases.cpp new file mode 100644 index 0000000..9141a4b --- /dev/null +++ b/test/has_bases.cpp @@ -0,0 +1,20 @@ + +#include +#include +#include + +struct y {}; +struct z {}; + +struct x : y, z { + typedef boost::mpl::vector base_types; +}; + +int main() { + BOOST_TEST(!boost::contract::aux::has_bases::value); + BOOST_TEST(boost::contract::aux::has_bases::value); + BOOST_TEST((boost::is_same::type, + boost::mpl::vector >::value)); + return boost::report_errors(); +} + diff --git a/test/has_invariant.cpp b/test/has_invariant.cpp new file mode 100644 index 0000000..711f895 --- /dev/null +++ b/test/has_invariant.cpp @@ -0,0 +1,64 @@ + +#include +#include + +struct x {}; // Test no invariants. + +struct c { + void invariant() const {} // Test const invariant. +}; + +struct cv { + void invariant() const volatile {} // Test const volatile invariant. +}; + +struct i { + void invariant() {} // Test non-const, non-volatile invariant. +}; + +struct si { + static void invariant() {} // Test static invariant. +}; + +struct s { + static void static_invariant() {} // Test static invariant. +}; + +struct ns { + void static_invariant() {} // Test non-static invariant. +}; + +int main() { + BOOST_TEST(!boost::contract::aux::has_const_invariant::value); + BOOST_TEST(!boost::contract::aux::has_const_volatile_invariant::value); + BOOST_TEST(!boost::contract::aux::has_invariant::value); + BOOST_TEST(!boost::contract::aux::has_static_invariant::value); + BOOST_TEST(!boost::contract::aux::has_non_static_invariant::value); + + BOOST_TEST( boost::contract::aux::has_const_invariant::value); + BOOST_TEST(!boost::contract::aux::has_const_volatile_invariant::value); + BOOST_TEST(!boost::contract::aux::has_invariant::value); + BOOST_TEST(!boost::contract::aux::has_static_invariant::value); + BOOST_TEST(!boost::contract::aux::has_non_static_invariant::value); + + BOOST_TEST(!boost::contract::aux::has_const_invariant::value); + BOOST_TEST( boost::contract::aux::has_const_volatile_invariant::value); + BOOST_TEST(!boost::contract::aux::has_invariant::value); + BOOST_TEST(!boost::contract::aux::has_static_invariant::value); + BOOST_TEST(!boost::contract::aux::has_non_static_invariant::value); + + BOOST_TEST(!boost::contract::aux::has_const_invariant::value); + BOOST_TEST(!boost::contract::aux::has_const_volatile_invariant::value); + BOOST_TEST( boost::contract::aux::has_invariant::value); + BOOST_TEST(!boost::contract::aux::has_static_invariant::value); + BOOST_TEST(!boost::contract::aux::has_non_static_invariant::value); + + BOOST_TEST(!boost::contract::aux::has_const_invariant::value); + BOOST_TEST(!boost::contract::aux::has_const_volatile_invariant::value); + BOOST_TEST(!boost::contract::aux::has_invariant::value); + BOOST_TEST(!boost::contract::aux::has_static_invariant::value); + BOOST_TEST( boost::contract::aux::has_non_static_invariant::value); + + return boost::report_errors(); +} + diff --git a/test/introspect.cpp b/test/introspect.cpp new file mode 100644 index 0000000..e21e7d7 --- /dev/null +++ b/test/introspect.cpp @@ -0,0 +1,39 @@ + +#include +#include +#include + +struct w {}; + +struct z { + char f(int) { return 'z'; } +}; + +struct y { + int f(char) { return -1; } +}; + +struct x { + int f(char) { + BOOST_TEST((introspect_f::has_member_function >::value)); + BOOST_TEST((!introspect_f::has_member_function >::value)); + BOOST_TEST((!introspect_f::has_member_function >::value)); + + BOOST_TEST((introspect_f::member_function_address() == &y::f)); + + return 'x'; + } +private: + BOOST_CONTRACT_INTROSPECT(f) +}; + +int main() { + x xx; + xx.f('a'); + return 0; +} + diff --git a/test/pp_class_traits/bases.cpp b/test/pp_class_traits/bases.cpp deleted file mode 100644 index 4eefe14..0000000 --- a/test/pp_class_traits/bases.cpp +++ /dev/null @@ -1,109 +0,0 @@ - -#include -#if !BOOST_PP_VARIADICS -# error "this compiler does not support variadic macros" -#else - -#include -#define BOOST_CONTRACT_EXT_PP_CLASS_TRAITS_AUX_INDEX_TEST \ - BOOST_CONTRACT_EXT_PP_TRAITS_AUX_INDEX_CLASS_BASES - -#include "../aux_/pp_traits.hpp" -#include "../aux_/pp_1tuple_rem.hpp" -#include -#include -#include -#include -#include -#include -#include - -#define BOOST_CONTRACT_TEST_BASE_(r, unused, i, base_traits) \ - BOOST_PP_COMMA_IF(i) \ - BOOST_CONTRACT_EXT_PP_BASE_TRAITS_ACCESS(base_traits) \ - BOOST_CONTRACT_EXT_PP_BASE_TRAITS_VIRTUAL(base_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_BASE_TRAITS_TYPE(base_traits)) - -#define BOOST_CONTRACT_TEST_BASES_YES_(class_traits) \ - extends( \ - BOOST_PP_SEQ_FOR_EACH_I(BOOST_CONTRACT_TEST_BASE_, ~, \ - BOOST_CONTRACT_EXT_PP_CLASS_TRAITS_BASES(class_traits)) \ - ) - -#define BOOST_CONTRACT_TEST_BASES_(class_traits) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_CLASS_TRAITS_BASES(class_traits)), \ - BOOST_PP_TUPLE_EAT(1) \ - , \ - BOOST_CONTRACT_TEST_BASES_YES_ \ - )(class_traits) - -#define BOOST_CONTRACT_TEST_EQUAL_(extends, parsed_extends) \ - BOOST_CONTRACT_TEST_AUX_PP_TRAITS( \ - BOOST_CONTRACT_TEST_BASES_, \ - BOOST_CONTRACT_EXT_PP_CLASS_TRAITS_PARSE_D, \ - template( typename T, (std::map::value_type) V ) \ - class (a), \ - extends, \ - BOOST_PP_EMPTY(), \ - parsed_extends \ - ) - -#define BOOST_CONTRACT_TEST_(extends) \ - BOOST_CONTRACT_TEST_EQUAL_(extends, extends) - -int main ( ) { - BOOST_CONTRACT_TEST_( BOOST_PP_EMPTY() ) - - BOOST_CONTRACT_TEST_( extends( b ) ) - BOOST_CONTRACT_TEST_( extends( virtual b ) ) - - BOOST_CONTRACT_TEST_( extends( public b ) ) - BOOST_CONTRACT_TEST_( extends( public virtual b ) ) - BOOST_CONTRACT_TEST_EQUAL_( - extends( virtual public b ), - extends( public virtual b ) - ) - - BOOST_CONTRACT_TEST_( extends( protected b ) ) - BOOST_CONTRACT_TEST_( extends( protected virtual b ) ) - BOOST_CONTRACT_TEST_EQUAL_( - extends( virtual protected b ), - extends( protected virtual b ) - ) - - BOOST_CONTRACT_TEST_( extends( private b ) ) - BOOST_CONTRACT_TEST_( extends( private virtual b ) ) - BOOST_CONTRACT_TEST_EQUAL_( - extends( virtual private b ), - extends( private virtual b ) - ) - - // Test base type with commas. - BOOST_CONTRACT_TEST_( extends( (std::map) ) ) - BOOST_CONTRACT_TEST_( extends( public virtual (std::map) ) ) - - // Test multiple inheritance (and a bit of everything together). - BOOST_CONTRACT_TEST_EQUAL_( - extends( - b, - virtual c, - public d, - protected virtual d, - virtual private (std::map::value_type) - ), - extends( - b, - virtual c, - public d, - protected virtual d, - private virtual (std::map::value_type) - ) - ) - - return BOOST_CONTRACT_TEST_AUX_PP_TRAITS_REPORT_ERRORS; -} - -#endif // variadics - diff --git a/test/pp_class_traits/export.cpp b/test/pp_class_traits/export.cpp deleted file mode 100644 index 31f526b..0000000 --- a/test/pp_class_traits/export.cpp +++ /dev/null @@ -1,33 +0,0 @@ - -#include -#if !BOOST_PP_VARIADICS -# error "this compiler does not support variadic macros" -#else - -#include -#define BOOST_CONTRACT_EXT_PP_CLASS_TRAITS_AUX_INDEX_TEST \ - BOOST_CONTRACT_EXT_PP_TRAITS_AUX_INDEX_CLASS_EXPORT - -#include "../aux_/pp_traits.hpp" -#include -#include - -#define BOOST_CONTRACT_TEST_(export_) \ - BOOST_CONTRACT_TEST_AUX_PP_TRAITS( \ - BOOST_CONTRACT_EXT_PP_CLASS_TRAITS_EXPORT, \ - BOOST_CONTRACT_EXT_PP_CLASS_TRAITS_PARSE_D, \ - BOOST_PP_EMPTY(), \ - export_, \ - template( typename T, (std::map::value_type) V ) \ - class (a) extends( b, c ), \ - export_ \ - ) - -int main ( ) { - BOOST_CONTRACT_TEST_( BOOST_PP_EMPTY() ) - BOOST_CONTRACT_TEST_( export ) - return BOOST_CONTRACT_TEST_AUX_PP_TRAITS_REPORT_ERRORS; -} - -#endif // variadics - diff --git a/test/pp_class_traits/friend.cpp b/test/pp_class_traits/friend.cpp deleted file mode 100644 index b2c4730..0000000 --- a/test/pp_class_traits/friend.cpp +++ /dev/null @@ -1,32 +0,0 @@ - -#include -#if !BOOST_PP_VARIADICS -# error "this compiler does not support variadic macros" -#else - -#include -#define BOOST_CONTRACT_EXT_PP_CLASS_TRAITS_AUX_INDEX_TEST \ - BOOST_CONTRACT_EXT_PP_TRAITS_AUX_INDEX_CLASS_FRIEND - -#include "../aux_/pp_traits.hpp" -#include -#include - -#define BOOST_CONTRACT_TEST_(friend_) \ - BOOST_CONTRACT_TEST_AUX_PP_TRAITS( \ - BOOST_CONTRACT_EXT_PP_CLASS_TRAITS_FRIEND, \ - BOOST_CONTRACT_EXT_PP_CLASS_TRAITS_PARSE_D, \ - template( typename T, (std::map::value_type) V ), \ - friend_, \ - class (a) extends( b, c ), \ - friend_ \ - ) - -int main ( ) { - BOOST_CONTRACT_TEST_( BOOST_PP_EMPTY() ) - BOOST_CONTRACT_TEST_( friend ) - return BOOST_CONTRACT_TEST_AUX_PP_TRAITS_REPORT_ERRORS; -} - -#endif // variadics - diff --git a/test/pp_class_traits/key.cpp b/test/pp_class_traits/key.cpp deleted file mode 100644 index a753557..0000000 --- a/test/pp_class_traits/key.cpp +++ /dev/null @@ -1,32 +0,0 @@ - -#include -#if !BOOST_PP_VARIADICS -# error "this compiler does not support variadic macros" -#else - -#include -#define BOOST_CONTRACT_EXT_PP_CLASS_TRAITS_AUX_INDEX_TEST \ - BOOST_CONTRACT_EXT_PP_TRAITS_AUX_INDEX_CLASS_KEY - -#include "../aux_/pp_traits.hpp" -#include -#include - -#define BOOST_CONTRACT_TEST_(key) \ - BOOST_CONTRACT_TEST_AUX_PP_TRAITS( \ - BOOST_CONTRACT_EXT_PP_CLASS_TRAITS_KEY, \ - BOOST_CONTRACT_EXT_PP_CLASS_TRAITS_PARSE_D, \ - template( typename T, (std::map::value_type) V ), \ - key, \ - (a) extends( b, c ), \ - key \ - ) - -int main ( ) { - BOOST_CONTRACT_TEST_( class ) - BOOST_CONTRACT_TEST_( struct ) - return BOOST_CONTRACT_TEST_AUX_PP_TRAITS_REPORT_ERRORS; -} - -#endif // variadics - diff --git a/test/pp_class_traits/name.cpp b/test/pp_class_traits/name.cpp deleted file mode 100644 index 3042193..0000000 --- a/test/pp_class_traits/name.cpp +++ /dev/null @@ -1,30 +0,0 @@ - -#include -#if !BOOST_PP_VARIADICS -# error "this compiler does not support variadic macros" -#else - -#include -#define BOOST_CONTRACT_EXT_PP_CLASS_TRAITS_AUX_INDEX_TEST \ - BOOST_CONTRACT_EXT_PP_TRAITS_AUX_INDEX_CLASS_NAME - -#include "../aux_/pp_traits.hpp" -#include - -#define BOOST_CONTRACT_TEST_(name) \ - BOOST_CONTRACT_TEST_AUX_PP_TRAITS( \ - BOOST_CONTRACT_EXT_PP_CLASS_TRAITS_NAME, \ - BOOST_CONTRACT_EXT_PP_CLASS_TRAITS_PARSE_D, \ - template( typename T, (std::map::value_type) V ) class, \ - (name), \ - extends( b, c ), \ - name \ - ) - -int main ( ) { - BOOST_CONTRACT_TEST_( a ) - return BOOST_CONTRACT_TEST_AUX_PP_TRAITS_REPORT_ERRORS; -} - -#endif // variadics - diff --git a/test/pp_class_traits/specialization.cpp b/test/pp_class_traits/specialization.cpp deleted file mode 100644 index b368082..0000000 --- a/test/pp_class_traits/specialization.cpp +++ /dev/null @@ -1,32 +0,0 @@ - -#include -#if !BOOST_PP_VARIADICS -# error "this compiler does not support variadic macros" -#else - -#include -#define BOOST_CONTRACT_EXT_PP_CLASS_TRAITS_AUX_INDEX_TEST \ - BOOST_CONTRACT_EXT_PP_TRAITS_AUX_INDEX_CLASS_SPECIALIZATION - -#include "../aux_/pp_traits.hpp" -#include - -#define BOOST_CONTRACT_TEST_(specialization) \ - BOOST_CONTRACT_TEST_AUX_PP_TRAITS( \ - BOOST_CONTRACT_EXT_PP_CLASS_TRAITS_SPECIALIZATION, \ - BOOST_CONTRACT_EXT_PP_CLASS_TRAITS_PARSE_D, \ - template( typename T, (std::map::value_type) V ) \ - class (a), \ - specialization, \ - extends( b, c ), \ - specialization \ - ) - -int main ( ) { - BOOST_CONTRACT_TEST_( BOOST_PP_EMPTY() ) - BOOST_CONTRACT_TEST_( ( T, V, std::pair const& ) ) - return BOOST_CONTRACT_TEST_AUX_PP_TRAITS_REPORT_ERRORS; -} - -#endif // variadics - diff --git a/test/pp_class_traits/template.cpp b/test/pp_class_traits/template.cpp deleted file mode 100644 index d540773..0000000 --- a/test/pp_class_traits/template.cpp +++ /dev/null @@ -1,39 +0,0 @@ - -#include -#if !BOOST_PP_VARIADICS -# error "this compiler does not support variadic macros" -#else - -#include -#define BOOST_CONTRACT_EXT_PP_CLASS_TRAITS_AUX_INDEX_TEST \ - BOOST_CONTRACT_EXT_PP_TRAITS_AUX_INDEX_CLASS_TEMPLATE - -#include "../aux_/pp_traits.hpp" -#include -#include - -#define BOOST_CONTRACT_TEST_TEMPLATE_(class_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_TEMPLATE( \ - BOOST_CONTRACT_EXT_PP_CLASS_TRAITS_TEMPLATE(class_traits), \ - BOOST_CONTRACT_EXT_PP_CLASS_TRAITS_TEMPLATE_PARAMS(class_traits) \ - ) - -#define BOOST_CONTRACT_TEST_AUX_PP_TEMPLATE_CHECK(template_params) \ - BOOST_CONTRACT_TEST_AUX_PP_TRAITS( \ - BOOST_CONTRACT_TEST_TEMPLATE_, \ - BOOST_CONTRACT_EXT_PP_CLASS_TRAITS_PARSE_D, \ - BOOST_PP_EMPTY(), \ - template_params, \ - class (a) extends( b, c ), \ - template_params \ - ) - -#include "../aux_/pp_template.hpp" - -int main ( ) { - boost::contract::test::aux::pp_template(); - return BOOST_CONTRACT_TEST_AUX_PP_TRAITS_REPORT_ERRORS; -} - -#endif // variadics - diff --git a/test/pp_class_traits/verbatim.cpp b/test/pp_class_traits/verbatim.cpp deleted file mode 100644 index 8f06a5f..0000000 --- a/test/pp_class_traits/verbatim.cpp +++ /dev/null @@ -1,41 +0,0 @@ - -#include -#if !BOOST_PP_VARIADICS -# error "this compiler does not support variadic macros" -#else - -#include -#define BOOST_CONTRACT_EXT_PP_CLASS_TRAITS_AUX_INDEX_TEST \ - BOOST_CONTRACT_EXT_PP_TRAITS_AUX_INDEX_CLASS_VERBATIM - -#include "../aux_/pp_traits.hpp" -#include -#include -#include -#include -#include -#include - -#define BOOST_CONTRACT_TEST_AUX_PP_VERBATIM_CHECK(verbatim) \ - BOOST_CONTRACT_TEST_AUX_PP_TRAITS( \ - BOOST_CONTRACT_EXT_PP_CLASS_TRAITS_VERBATIM, \ - BOOST_CONTRACT_EXT_PP_CLASS_TRAITS_PARSE_D, \ - template( typename T, (std::map::value_type) V ) class, \ - verbatim, \ - (a) extens( b, c ), \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY(verbatim), \ - BOOST_PP_TUPLE_EAT(1) \ - , \ - BOOST_CONTRACT_EXT_PP_KEYWORD_VERBATIM_REMOVE_FRONT \ - )(verbatim) \ - ) - -#include "../aux_/pp_verbatim.hpp" - -int main ( ) { - boost::contract::test::aux::pp_verbatim(); - return BOOST_CONTRACT_TEST_AUX_PP_TRAITS_REPORT_ERRORS; -} - -#endif // variadics - diff --git a/test/pp_class_traits/virt.cpp b/test/pp_class_traits/virt.cpp deleted file mode 100644 index bb43595..0000000 --- a/test/pp_class_traits/virt.cpp +++ /dev/null @@ -1,33 +0,0 @@ - -#include -#if !BOOST_PP_VARIADICS -# error "this compiler does not support variadic macros" -#else - -#include -#define BOOST_CONTRACT_EXT_PP_CLASS_TRAITS_AUX_INDEX_TEST \ - BOOST_CONTRACT_EXT_PP_TRAITS_AUX_INDEX_CLASS_VIRT - -#include "../aux_/pp_traits.hpp" -#include -#include - -#define BOOST_CONTRACT_TEST_(virt) \ - BOOST_CONTRACT_TEST_AUX_PP_TRAITS( \ - BOOST_CONTRACT_EXT_PP_CLASS_TRAITS_FINAL, \ - BOOST_CONTRACT_EXT_PP_CLASS_TRAITS_PARSE_D, \ - template( typename T, (std::map::value_type) V ) \ - class (a), \ - virt, \ - extends( b, c ), \ - virt \ - ) - -int main ( ) { - BOOST_CONTRACT_TEST_( BOOST_PP_EMPTY() ) - BOOST_CONTRACT_TEST_( final ) - return BOOST_CONTRACT_TEST_AUX_PP_TRAITS_REPORT_ERRORS; -} - -#endif // variadics - diff --git a/test/pp_func_traits/access.cpp b/test/pp_func_traits/access.cpp deleted file mode 100644 index a1cf04f..0000000 --- a/test/pp_func_traits/access.cpp +++ /dev/null @@ -1,34 +0,0 @@ - -#include -#if !BOOST_PP_VARIADICS -# error "this compiler does not support variadic macros" -#else - -#include -#define BOOST_CONTRACT_EXT_PP_FUNC_TRAITS_AUX_INDEX_TEST \ - BOOST_CONTRACT_EXT_PP_TRAITS_AUX_INDEX_FUNC_ACCESS - -#include "../aux_/pp_traits.hpp" -#include -#include - -#define BOOST_CONTRACT_TEST_(access) \ - BOOST_CONTRACT_TEST_AUX_PP_TRAITS( \ - BOOST_CONTRACT_EXT_PP_FUNC_TRAITS_ACCESS, \ - BOOST_CONTRACT_EXT_PP_FUNC_TRAITS_PARSE_D, \ - BOOST_PP_EMPTY(), \ - access, \ - (std::map&) (f) ( int x, (std::map&) y ), \ - access \ - ) - -int main ( ) { - BOOST_CONTRACT_TEST_( BOOST_PP_EMPTY() ) - BOOST_CONTRACT_TEST_( public ) - BOOST_CONTRACT_TEST_( protected ) - BOOST_CONTRACT_TEST_( private ) - return BOOST_CONTRACT_TEST_AUX_PP_TRAITS_REPORT_ERRORS; -} - -#endif // variadics - diff --git a/test/pp_func_traits/assertions.hpp b/test/pp_func_traits/assertions.hpp deleted file mode 100644 index 536f9a0..0000000 --- a/test/pp_func_traits/assertions.hpp +++ /dev/null @@ -1,98 +0,0 @@ - -// NOTE: This header does not use #include guards. - -#ifndef BOOST_CONTRACT_TEST_ASSERTIONS_equal -# error "#undefined header macro parameter" -#endif -#ifndef BOOST_CONTRACT_TEST_ASSERTIONS_check -# error "#undefined header macro parameter" -#endif -#ifndef BOOST_CONTRACT_TEST_ASSERTIONS_post -# error "#undefined header macro parameter (can be #defined to empty)" -#endif -#ifndef BOOST_CONTRACT_TEST_ASSERTIONS_post_if -# error "#undefined header macro parameter (can be #defined to empty)" -#endif - -// Test no postconditions. -BOOST_CONTRACT_TEST_ASSERTIONS_equal( BOOST_PP_EMPTY(), ( ) ) -// Test empty postconditions. -BOOST_CONTRACT_TEST_ASSERTIONS_check( ( ) ) - -// Test no trailing comma. -BOOST_CONTRACT_TEST_ASSERTIONS_equal( ( x >= 0, y, z ), ( x >= 0, y, z, ) ) - -// Test everything together. -BOOST_CONTRACT_TEST_ASSERTIONS_check( ( - before, - - namespace (py) as boost::python, - - // Using directives. - using namespace std, - // Using declarations. - using std::placeholders::_1, - using typename T::value_type, - using (std::map::insert), - using (typename M::key_type), - // Using aliases. - using (iv) as vector, - using (icmap) as (map), - template( typename T ) using (vt) as vector, - template( typename T, int U ) using (xtu) as (x), - - typedef unsigned long ul, - typedef (map) icmap, - - BOOST_CONTRACT_TEST_ASSERTIONS_post - - const( std::cout ) !std::cout.error(), - const( std::cout, x ) std::cout.flags == x, - const( ) true, - const( int const n, x, (::std::map const&) m ) - (m.size() == map::key_size == x), - - x >= 0, - x == 0 ? !result : true, - (!y), - (std::map::key_size > 0), - - - if(m::value) ( - a >= 0, - typedef bool b, - - BOOST_CONTRACT_TEST_ASSERTIONS_post_if - - d >= v.size(), - ) else ( - x, - if(const( y, z ) y >= z) ( - y, - z, - ) else ( - u, - v, - ) - // TODO: A `static if ...` seems to not work... why? Test it. - w, - ) - - static if(is_same::value) ( - x == y, - ) else ( - x, - y, - ) - - after, -) ) - -#define BOOST_CONTRACT_TEST_ASSERTIONS_if if -#include "./if_assertions.hpp" // Include actual if-assertion tests. -#undef BOOST_CONTRACT_TEST_ASSERTIONS_if - -#define BOOST_CONTRACT_TEST_ASSERTIONS_if static if -#include "./if_assertions.hpp" // Include actual static-if-assertion tests. -#undef BOOST_CONTRACT_TEST_ASSERTIONS_if - diff --git a/test/pp_func_traits/classifiers.cpp b/test/pp_func_traits/classifiers.cpp deleted file mode 100644 index 7c56cbf..0000000 --- a/test/pp_func_traits/classifiers.cpp +++ /dev/null @@ -1,105 +0,0 @@ - -#include -#if !BOOST_PP_VARIADICS -# error "this compiler does not support variadic macros" -#else - -#include -#define BOOST_CONTRACT_EXT_PP_FUNC_TRAITS_AUX_INDEX_TEST \ - BOOST_CONTRACT_EXT_PP_TRAITS_AUX_INDEX_FUNC_CLASSIFIERS - -#include "../aux_/pp_traits.hpp" -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#define BOOST_CONTRACT_TEST_FIND_(r, classifier_upper, classifier) \ - BOOST_PP_EXPR_IIF(BOOST_PP_SEQ_CAT((BOOST_CONTRACT_EXT_PP_KEYWORD_IS_) \ - (classifier_upper)(_FRONT))(classifier), \ - classifier \ - ) - -#define BOOST_CONTRACT_TEST_ELEM_(r, unused, classifier) classifier - -#define BOOST_CONTRACT_TEST_TRAIT_(classifier_upper, classifiers_list) \ - BOOST_CONTRACT_TEST_AUX_PP_TRAITS( \ - BOOST_PP_CAT(BOOST_CONTRACT_EXT_PP_FUNC_TRAITS_, classifier_upper), \ - BOOST_CONTRACT_EXT_PP_FUNC_TRAITS_PARSE_D, \ - template( typename T, (std::map::value_type) V ), \ - BOOST_PP_LIST_FOR_EACH(BOOST_CONTRACT_TEST_ELEM_, ~, \ - classifiers_list), \ - (std::map&) (f) ( int x, (std::map&) y ), \ - BOOST_PP_LIST_FOR_EACH(BOOST_CONTRACT_TEST_FIND_, classifier_upper, \ - classifiers_list) \ - ) - -#define BOOST_CONTRACT_TEST_LIST_(classifiers_list) \ - BOOST_CONTRACT_TEST_TRAIT_(INLINE, classifiers_list) \ - BOOST_CONTRACT_TEST_TRAIT_(STATIC, classifiers_list) \ - BOOST_CONTRACT_TEST_TRAIT_(EXTERN, classifiers_list) \ - BOOST_CONTRACT_TEST_TRAIT_(EXPLICIT, classifiers_list) \ - BOOST_CONTRACT_TEST_TRAIT_(VIRTUAL, classifiers_list) \ - BOOST_CONTRACT_TEST_TRAIT_(FRIEND, classifiers_list) - -#define BOOST_CONTRACT_TEST_(classifiers_seq) \ - BOOST_CONTRACT_TEST_LIST_( \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY(classifiers_seq), \ - BOOST_PP_NIL BOOST_PP_TUPLE_EAT(1) \ - , \ - BOOST_PP_SEQ_TO_LIST \ - )(classifiers_seq) \ - ) - -int main ( ) { - // Test a few combinations verified to be valid C++. (Other combinations - // are also supported by the macro syntax but it would be overwhelming to - // test them all and of little use given they are not valid C++.) - - BOOST_CONTRACT_TEST_( BOOST_PP_EMPTY() ) - - BOOST_CONTRACT_TEST_( (inline) ) - - BOOST_CONTRACT_TEST_( (static) ) - BOOST_CONTRACT_TEST_( (static) (inline) ) - BOOST_CONTRACT_TEST_( (inline) (static) ) - - BOOST_CONTRACT_TEST_( (extern) ) - BOOST_CONTRACT_TEST_( (extern) (inline) ) - BOOST_CONTRACT_TEST_( (inline) (extern) ) - - // This triplet combination is valid for C++11 type-conversion operators. - BOOST_CONTRACT_TEST_( (explicit) (inline) (virtual) ) - BOOST_CONTRACT_TEST_( (explicit) (virtual) (inline) ) - - BOOST_CONTRACT_TEST_( (inline) (explicit) (virtual) ) - BOOST_CONTRACT_TEST_( (inline) (virtual) (explicit) ) - - BOOST_CONTRACT_TEST_( (virtual) (explicit) (inline) ) - BOOST_CONTRACT_TEST_( (virtual) (inline) (explicit) ) - - BOOST_CONTRACT_TEST_( (explicit) (virtual) ) - BOOST_CONTRACT_TEST_( (virtual) (explicit) ) - - BOOST_CONTRACT_TEST_( (explicit) ) - BOOST_CONTRACT_TEST_( (explicit) (inline) ) - BOOST_CONTRACT_TEST_( (inline) (explicit) ) - - BOOST_CONTRACT_TEST_( (virtual) ) - BOOST_CONTRACT_TEST_( (virtual) (inline) ) - BOOST_CONTRACT_TEST_( (inline) (virtual) ) - - BOOST_CONTRACT_TEST_( (friend) ) - BOOST_CONTRACT_TEST_( (friend) (inline) ) - BOOST_CONTRACT_TEST_( (inline) (friend) ) - - return BOOST_CONTRACT_TEST_AUX_PP_TRAITS_REPORT_ERRORS; -} - -#endif // variadics - diff --git a/test/pp_func_traits/cv.cpp b/test/pp_func_traits/cv.cpp deleted file mode 100644 index d0da0a2..0000000 --- a/test/pp_func_traits/cv.cpp +++ /dev/null @@ -1,46 +0,0 @@ - -#include -#if !BOOST_PP_VARIADICS -# error "this compiler does not support variadic macros" -#else - -#include -#define BOOST_CONTRACT_EXT_PP_FUNC_TRAITS_AUX_INDEX_TEST \ - BOOST_CONTRACT_EXT_PP_TRAITS_AUX_INDEX_FUNC_CV - -#include "../aux_/pp_traits.hpp" -#include -#include - -#define BOOST_CONTRACT_TEST_CV_(func_traits) \ - BOOST_CONTRACT_EXT_PP_FUNC_TRAITS_CONST(func_traits) \ - BOOST_CONTRACT_EXT_PP_FUNC_TRAITS_VOLATILE(func_traits) - -#define BOOST_CONTRACT_TEST_EQUAL_(cv, parsed_cv) \ - BOOST_CONTRACT_TEST_AUX_PP_TRAITS( \ - BOOST_CONTRACT_TEST_CV_, \ - BOOST_CONTRACT_EXT_PP_FUNC_TRAITS_PARSE_D, \ - (std::map&) (f) ( int x, (std::map&) y ), \ - cv, \ - refref throw(int, double) final override, \ - parsed_cv \ - ) - -#define BOOST_CONTRACT_TEST_(cv) \ - BOOST_CONTRACT_TEST_EQUAL_(cv, cv) - -int main ( ) { - BOOST_CONTRACT_TEST_( BOOST_PP_EMPTY() ) - - BOOST_CONTRACT_TEST_( const ) - BOOST_CONTRACT_TEST_( volatile ) - - BOOST_CONTRACT_TEST_( const volatile ) - // Same as `const volatile` once parsed (this order does not matter in C++). - BOOST_CONTRACT_TEST_EQUAL_( volatile const, const volatile ) - - return BOOST_CONTRACT_TEST_AUX_PP_TRAITS_REPORT_ERRORS; -} - -#endif // variadics - diff --git a/test/pp_func_traits/except.cpp b/test/pp_func_traits/except.cpp deleted file mode 100644 index cb6df50..0000000 --- a/test/pp_func_traits/except.cpp +++ /dev/null @@ -1,40 +0,0 @@ - -#include -#if !BOOST_PP_VARIADICS -# error "this compiler does not support variadic macros" -#else - -#include -#define BOOST_CONTRACT_EXT_PP_FUNC_TRAITS_AUX_INDEX_TEST \ - BOOST_CONTRACT_EXT_PP_TRAITS_AUX_INDEX_FUNC_EXCEPT - -#include "../aux_/pp_traits.hpp" -#include -#include - -#define BOOST_CONTRACT_TEST_(except) \ - BOOST_CONTRACT_TEST_AUX_PP_TRAITS( \ - BOOST_CONTRACT_EXT_PP_FUNC_TRAITS_EXCEPT, \ - BOOST_CONTRACT_EXT_PP_FUNC_TRAITS_PARSE_D, \ - (std::map&) (f) ( int x, (std::map&) y ) const, \ - except, \ - final override, \ - except \ - ) - -int main ( ) { - BOOST_CONTRACT_TEST_( BOOST_PP_EMPTY() ) - - BOOST_CONTRACT_TEST_( noexcept ) - BOOST_CONTRACT_TEST_( noexcept(sizeof(int) < 16) ) - BOOST_CONTRACT_TEST_( noexcept(my::map::key_size) ) - - BOOST_CONTRACT_TEST_( throw() ) - BOOST_CONTRACT_TEST_( throw(std::exception) ) - BOOST_CONTRACT_TEST_( throw(std::exception, my::map::error) ) - - return BOOST_CONTRACT_TEST_AUX_PP_TRAITS_REPORT_ERRORS; -} - -#endif // variadics - diff --git a/test/pp_func_traits/export.cpp b/test/pp_func_traits/export.cpp deleted file mode 100644 index 03da0af..0000000 --- a/test/pp_func_traits/export.cpp +++ /dev/null @@ -1,33 +0,0 @@ - -#include -#if !BOOST_PP_VARIADICS -# error "this compiler does not support variadic macros" -#else - -#include -#define BOOST_CONTRACT_EXT_PP_FUNC_TRAITS_AUX_INDEX_TEST \ - BOOST_CONTRACT_EXT_PP_TRAITS_AUX_INDEX_FUNC_EXPORT - -#include "../aux_/pp_traits.hpp" -#include -#include - -#define BOOST_CONTRACT_TEST_(export_) \ - BOOST_CONTRACT_TEST_AUX_PP_TRAITS( \ - BOOST_CONTRACT_EXT_PP_FUNC_TRAITS_EXPORT, \ - BOOST_CONTRACT_EXT_PP_FUNC_TRAITS_PARSE_D, \ - BOOST_PP_EMPTY(), \ - export_, \ - template( typename T, (std::map::value_type) V ) \ - (std::map&) (f) ( int x, (std::map&) y ), \ - export_ \ - ) - -int main ( ) { - BOOST_CONTRACT_TEST_( BOOST_PP_EMPTY() ) - BOOST_CONTRACT_TEST_( export ) - return BOOST_CONTRACT_TEST_AUX_PP_TRAITS_REPORT_ERRORS; -} - -#endif // variadics - diff --git a/test/pp_func_traits/if_assertions.hpp b/test/pp_func_traits/if_assertions.hpp deleted file mode 100644 index 9cfbed5..0000000 --- a/test/pp_func_traits/if_assertions.hpp +++ /dev/null @@ -1,275 +0,0 @@ - -// NOTE: This header does not use #include guards. - -#ifndef BOOST_CONTRACT_TEST_ASSERTIONS_equal -# error "#undefined header macro parameter" -#endif -#ifndef BOOST_CONTRACT_TEST_ASSERTIONS_check -# error "#undefined header macro parameter" -#endif -#ifndef BOOST_CONTRACT_TEST_ASSERTIONS_if -# error "#undefined header macro parameter (can be `if` or `static if`)" -#endif - -// Test if with all then statements and no else. -BOOST_CONTRACT_TEST_ASSERTIONS_equal( ( - x, BOOST_CONTRACT_TEST_ASSERTIONS_if(c), y, -), ( - x, BOOST_CONTRACT_TEST_ASSERTIONS_if(c) ( ) else ( ) y, -) ) -BOOST_CONTRACT_TEST_ASSERTIONS_equal( ( - x, BOOST_CONTRACT_TEST_ASSERTIONS_if(c) ( ) y, -), ( - x, BOOST_CONTRACT_TEST_ASSERTIONS_if(c) ( ) else ( ) y, -) ) -BOOST_CONTRACT_TEST_ASSERTIONS_equal( ( - x, BOOST_CONTRACT_TEST_ASSERTIONS_if(c) ( t1, t2, ) y, -), ( - x, BOOST_CONTRACT_TEST_ASSERTIONS_if(c) ( t1, t2, ) else ( ) y, -) ) -BOOST_CONTRACT_TEST_ASSERTIONS_equal( ( - x, BOOST_CONTRACT_TEST_ASSERTIONS_if(c) ( t1, t2, ), y, -), ( - x, BOOST_CONTRACT_TEST_ASSERTIONS_if(c) ( t1, t2, ) else ( ) y, -) ) -BOOST_CONTRACT_TEST_ASSERTIONS_equal( ( - x, BOOST_CONTRACT_TEST_ASSERTIONS_if(c) t1, y, -), ( - x, BOOST_CONTRACT_TEST_ASSERTIONS_if(c) ( t1, ) else ( ) y, -) ) - -// Test if with empty then and all else statements. -BOOST_CONTRACT_TEST_ASSERTIONS_equal( ( - x, BOOST_CONTRACT_TEST_ASSERTIONS_if(c) ( ) else, y, -), ( - x, BOOST_CONTRACT_TEST_ASSERTIONS_if(c) ( ) else ( ) y, -) ) -BOOST_CONTRACT_TEST_ASSERTIONS_check( ( - x, BOOST_CONTRACT_TEST_ASSERTIONS_if(c) ( ) else ( ) y, -) ) -BOOST_CONTRACT_TEST_ASSERTIONS_check( ( - x, BOOST_CONTRACT_TEST_ASSERTIONS_if(c) ( ) else ( e1, e2, ) y, -) ) -BOOST_CONTRACT_TEST_ASSERTIONS_equal( ( - x, BOOST_CONTRACT_TEST_ASSERTIONS_if(c) ( ) else ( e1, e2, ), y, -), ( - x, BOOST_CONTRACT_TEST_ASSERTIONS_if(c) ( ) else ( e1, e2, ) y, -) ) -BOOST_CONTRACT_TEST_ASSERTIONS_equal( ( - x, BOOST_CONTRACT_TEST_ASSERTIONS_if(c) ( ) else e1, y, -), ( - x, BOOST_CONTRACT_TEST_ASSERTIONS_if(c) ( ) else ( e1, ) y, -) ) - -// Test if with non-empty then and all else statements. -BOOST_CONTRACT_TEST_ASSERTIONS_equal( ( - x, BOOST_CONTRACT_TEST_ASSERTIONS_if(c) ( t1, t2, ) else, y, -), ( - x, BOOST_CONTRACT_TEST_ASSERTIONS_if(c) ( t1, t2, ) else ( ) y, -) ) -BOOST_CONTRACT_TEST_ASSERTIONS_check( ( - x, BOOST_CONTRACT_TEST_ASSERTIONS_if(c) ( t1, t2, ) else ( ) y, -) ) -BOOST_CONTRACT_TEST_ASSERTIONS_check( ( - x, BOOST_CONTRACT_TEST_ASSERTIONS_if(c) ( t1, t2, ) else ( e1, e2, ) y, -) ) -BOOST_CONTRACT_TEST_ASSERTIONS_equal( ( - x, BOOST_CONTRACT_TEST_ASSERTIONS_if(c) ( t1, t2, ) else ( e1, e2, ), y, -), ( - x, BOOST_CONTRACT_TEST_ASSERTIONS_if(c) ( t1, t2, ) else ( e1, e2, ) y, -) ) -BOOST_CONTRACT_TEST_ASSERTIONS_equal( ( - x, BOOST_CONTRACT_TEST_ASSERTIONS_if(c) ( t1, t2, ) else e1, y, -), ( - x, BOOST_CONTRACT_TEST_ASSERTIONS_if(c) ( t1, t2, ) else ( e1, ) y, -) ) - -// Test if with no then, a comma, and all else statements (allowed in C++). -BOOST_CONTRACT_TEST_ASSERTIONS_equal( ( - x, BOOST_CONTRACT_TEST_ASSERTIONS_if(c), else, y, -), ( - x, BOOST_CONTRACT_TEST_ASSERTIONS_if(c) ( ) else ( ) y, -) ) -BOOST_CONTRACT_TEST_ASSERTIONS_equal( ( - x, BOOST_CONTRACT_TEST_ASSERTIONS_if(c), else ( ) y, -), ( - x, BOOST_CONTRACT_TEST_ASSERTIONS_if(c) ( ) else ( ) y, -) ) -BOOST_CONTRACT_TEST_ASSERTIONS_equal( ( - x, BOOST_CONTRACT_TEST_ASSERTIONS_if(c), else ( e1, e2, ) y, -), ( - x, BOOST_CONTRACT_TEST_ASSERTIONS_if(c) ( ) else ( e1, e2, ) y, -) ) -BOOST_CONTRACT_TEST_ASSERTIONS_equal( ( - x, BOOST_CONTRACT_TEST_ASSERTIONS_if(c), else ( e1, e2, ), y, -), ( - x, BOOST_CONTRACT_TEST_ASSERTIONS_if(c) ( ) else ( e1, e2, ) y, -) ) -BOOST_CONTRACT_TEST_ASSERTIONS_equal( ( - x, BOOST_CONTRACT_TEST_ASSERTIONS_if(c), else e1, y, -), ( - x, BOOST_CONTRACT_TEST_ASSERTIONS_if(c) ( ) else ( e1, ) y, -) ) - -// Test if with no then and all else statements (not allowed by C++ for no -// reason... so allowed by this syntax so less cryptic errors). -BOOST_CONTRACT_TEST_ASSERTIONS_equal( ( - x, BOOST_CONTRACT_TEST_ASSERTIONS_if(c) else, y, -), ( - x, BOOST_CONTRACT_TEST_ASSERTIONS_if(c) ( ) else ( ) y, -) ) -BOOST_CONTRACT_TEST_ASSERTIONS_equal( ( - x, BOOST_CONTRACT_TEST_ASSERTIONS_if(c) else ( ) y, -), ( - x, BOOST_CONTRACT_TEST_ASSERTIONS_if(c) ( ) else ( ) y, -) ) -BOOST_CONTRACT_TEST_ASSERTIONS_equal( ( - x, BOOST_CONTRACT_TEST_ASSERTIONS_if(c) else ( e1, e2, ) y, -), ( - x, BOOST_CONTRACT_TEST_ASSERTIONS_if(c) ( ) else ( e1, e2, ) y, -) ) -BOOST_CONTRACT_TEST_ASSERTIONS_equal( ( - x, BOOST_CONTRACT_TEST_ASSERTIONS_if(c) else ( e1, e2, ), y -), ( - x, BOOST_CONTRACT_TEST_ASSERTIONS_if(c) ( ) else ( e1, e2, ) y, -) ) -BOOST_CONTRACT_TEST_ASSERTIONS_equal( ( - x, BOOST_CONTRACT_TEST_ASSERTIONS_if(c) else e1, y, -), ( - x, BOOST_CONTRACT_TEST_ASSERTIONS_if(c) ( ) else ( e1, ) y, -) ) - -// Test if with empty then, a comma, and all else statements (not allowed by -// C++ for no reason... so allowed by this syntax so less cryptic errors). -BOOST_CONTRACT_TEST_ASSERTIONS_equal( ( - x, BOOST_CONTRACT_TEST_ASSERTIONS_if(c) ( ), else, y, -), ( - x, BOOST_CONTRACT_TEST_ASSERTIONS_if(c) ( ) else ( ) y, -) ) -BOOST_CONTRACT_TEST_ASSERTIONS_equal( ( - x, BOOST_CONTRACT_TEST_ASSERTIONS_if(c) ( ), else ( ) y, -), ( - x, BOOST_CONTRACT_TEST_ASSERTIONS_if(c) ( ) else ( ) y, -) ) -BOOST_CONTRACT_TEST_ASSERTIONS_equal( ( - x, BOOST_CONTRACT_TEST_ASSERTIONS_if(c) ( ), else ( e1, e2, ) y, -), ( - x, BOOST_CONTRACT_TEST_ASSERTIONS_if(c) ( ) else ( e1, e2, ) y, -) ) -BOOST_CONTRACT_TEST_ASSERTIONS_equal( ( - x, BOOST_CONTRACT_TEST_ASSERTIONS_if(c) ( ), else ( e1, e2, ), y, -), ( - x, BOOST_CONTRACT_TEST_ASSERTIONS_if(c) ( ) else ( e1, e2, ) y, -) ) -BOOST_CONTRACT_TEST_ASSERTIONS_equal( ( - x, BOOST_CONTRACT_TEST_ASSERTIONS_if(c) ( ), else e1, y, -), ( - x, BOOST_CONTRACT_TEST_ASSERTIONS_if(c) ( ) else ( e1, ) y, -) ) - -// Test if with non-empty then, a comma, and all else statements (not -// allowed by C++ for no reason... so allowed by this syntax so less -// cryptic errors). -BOOST_CONTRACT_TEST_ASSERTIONS_equal( ( - x, BOOST_CONTRACT_TEST_ASSERTIONS_if(c) ( t1, t2, ), else, y, -), ( - x, BOOST_CONTRACT_TEST_ASSERTIONS_if(c) ( t1, t2, ) else ( ) y, -) ) -BOOST_CONTRACT_TEST_ASSERTIONS_equal( ( - x, BOOST_CONTRACT_TEST_ASSERTIONS_if(c) ( t1, t2, ), else ( ) y, -), ( - x, BOOST_CONTRACT_TEST_ASSERTIONS_if(c) ( t1, t2, ) else ( ) y, -) ) -BOOST_CONTRACT_TEST_ASSERTIONS_equal( ( - x, BOOST_CONTRACT_TEST_ASSERTIONS_if(c) ( t1, t2, ), else ( e1, e2, ) y, -), ( - x, BOOST_CONTRACT_TEST_ASSERTIONS_if(c) ( t1, t2, ) else ( e1, e2, ) y, -) ) -BOOST_CONTRACT_TEST_ASSERTIONS_equal( ( - x, BOOST_CONTRACT_TEST_ASSERTIONS_if(c) ( t1, t2, ), else ( e1, e2, ), y, -), ( - x, BOOST_CONTRACT_TEST_ASSERTIONS_if(c) ( t1, t2, ) else ( e1, e2, ) y, -) ) -BOOST_CONTRACT_TEST_ASSERTIONS_equal( ( - x, BOOST_CONTRACT_TEST_ASSERTIONS_if(c) ( t1, t2, ), else e1, y, -), ( - x, BOOST_CONTRACT_TEST_ASSERTIONS_if(c) ( t1, t2, ) else ( e1, ) y, -) ) -// Test same as above with single then statement. -BOOST_CONTRACT_TEST_ASSERTIONS_equal( ( - x, BOOST_CONTRACT_TEST_ASSERTIONS_if(c) t1, else, y, -), ( - x, BOOST_CONTRACT_TEST_ASSERTIONS_if(c) ( t1, ) else ( ) y, -) ) -BOOST_CONTRACT_TEST_ASSERTIONS_equal( ( - x, BOOST_CONTRACT_TEST_ASSERTIONS_if(c) t1, else ( ) y, -), ( - x, BOOST_CONTRACT_TEST_ASSERTIONS_if(c) ( t1, ) else ( ) y, -) ) -BOOST_CONTRACT_TEST_ASSERTIONS_equal( ( - x, BOOST_CONTRACT_TEST_ASSERTIONS_if(c) t1, else ( e1, e2, ) y, -), ( - x, BOOST_CONTRACT_TEST_ASSERTIONS_if(c) ( t1, ) else ( e1, e2, ) y, -) ) -BOOST_CONTRACT_TEST_ASSERTIONS_equal( ( - x, BOOST_CONTRACT_TEST_ASSERTIONS_if(c) t1, else ( e1, e2, ), y, -), ( - x, BOOST_CONTRACT_TEST_ASSERTIONS_if(c) ( t1, ) else ( e1, e2, ) y, -) ) -BOOST_CONTRACT_TEST_ASSERTIONS_equal( ( - x, BOOST_CONTRACT_TEST_ASSERTIONS_if(c) t1, else e1, y, -), ( - x, BOOST_CONTRACT_TEST_ASSERTIONS_if(c) ( t1, ) else ( e1, ) y, -) ) - -// Extra else correctly treated as a boolean-assertion `bool(else e2)`. -BOOST_CONTRACT_TEST_ASSERTIONS_equal( ( - x, - BOOST_CONTRACT_TEST_ASSERTIONS_if(c) ( t1, t2, ), else e1, - else e2, - y, -), ( - x, - BOOST_CONTRACT_TEST_ASSERTIONS_if(c) ( t1, t2, ) else ( e1, ) - bool(else e2), - y, -) ) - -BOOST_CONTRACT_TEST_ASSERTIONS_equal( ( - x, - BOOST_CONTRACT_TEST_ASSERTIONS_if(c) ( - t1, - t2, - ) else BOOST_CONTRACT_TEST_ASSERTIONS_if(cc) ( - tt1, - tt2, - ) else BOOST_CONTRACT_TEST_ASSERTIONS_if(ccc) ( - ttt1, - ttt2, - ) else ( - e1, - e2, - ) - y, -), ( - x, - BOOST_CONTRACT_TEST_ASSERTIONS_if(c) ( - t1, - t2, - ) else ( - BOOST_CONTRACT_TEST_ASSERTIONS_if(cc) ( - tt1, - tt2, - ) else ( - BOOST_CONTRACT_TEST_ASSERTIONS_if(ccc) ( - ttt1, - ttt2, - ) else ( - e1, - e2, - ) - ) - ) - y, -) ) - diff --git a/test/pp_func_traits/name.cpp b/test/pp_func_traits/name.cpp deleted file mode 100644 index a4dcd93..0000000 --- a/test/pp_func_traits/name.cpp +++ /dev/null @@ -1,122 +0,0 @@ - -#include -#if !BOOST_PP_VARIADICS -# error "this compiler does not support variadic macros" -#else - -#include -#define BOOST_CONTRACT_EXT_PP_FUNC_TRAITS_AUX_INDEX_TEST \ - BOOST_CONTRACT_EXT_PP_TRAITS_AUX_INDEX_FUNC_NAME - -#include "../aux_/pp_traits.hpp" -#include -#include - -#define BOOST_CONTRACT_TEST_(before, name, after, \ - parsed_operator_name, parsed_func_name) \ - BOOST_CONTRACT_TEST_AUX_PP_TRAITS( \ - BOOST_CONTRACT_EXT_PP_FUNC_TRAITS_OPERATOR_NAME, \ - BOOST_CONTRACT_EXT_PP_FUNC_TRAITS_PARSE_D, \ - before, \ - name, \ - after, \ - parsed_operator_name \ - ) \ - BOOST_CONTRACT_TEST_AUX_PP_TRAITS( \ - BOOST_CONTRACT_EXT_PP_FUNC_TRAITS_NAME, \ - BOOST_CONTRACT_EXT_PP_FUNC_TRAITS_PARSE_D, \ - before, \ - name, \ - after, \ - parsed_func_name \ - ) - -int main ( ) { - // Test function name. - BOOST_CONTRACT_TEST_( - int, (f), ( int ), - BOOST_PP_EMPTY(), f - ) - - // Test constructor and destructor names. - BOOST_CONTRACT_TEST_( - explicit, (ctor), ( int n ), - BOOST_PP_EMPTY(), ctor - ) - BOOST_CONTRACT_TEST_( - virtual, (~dtor), ( ), - BOOST_PP_EMPTY(), ~dtor - ) - - // Test a few (non type conversion) operators. - BOOST_CONTRACT_TEST_( - template( typename L, typename R ) - auto, operator(+)(add), ( (L) l, (R) r ) return decltype(l + r), - (+), add - ) - BOOST_CONTRACT_TEST_( - long double, operator("" _deg)(deg_literal), ( long double deg ), - ("" _deg), deg_literal - ) - BOOST_CONTRACT_TEST_( - void, operator(())(call), ( int x ), - (()), call - ) - BOOST_CONTRACT_TEST_( - template( typename L, typename R ) - (R), operator(,)(comma), ( (L) l , (R) r ), - (,), comma - ) - BOOST_CONTRACT_TEST_( - (void*), operator(new[])(new_array), ( (std::size_t) size ), - (new[]), new_array - ) - BOOST_CONTRACT_TEST_( - void, operator(delete[])(delete_array), ( (void*) ptr ), - (delete[]), delete_array - ) - - // Test type conversion operators with and without commas. - BOOST_CONTRACT_TEST_( - explicit, operator(int*)(int_ptr), ( ), - (int*), int_ptr - ) - BOOST_CONTRACT_TEST_( - template( typename T ) - , operator(std::map)(std_map_int_T), ( ), - (std::map), std_map_int_T - ) - - // Test type conversion operators with and without operator name. - BOOST_CONTRACT_TEST_( - explicit, operator unsigned int, ( ) const, - (unsigned int), unsignedint - ) - BOOST_CONTRACT_TEST_( - explicit, operator(unsigned int)(unsigned_int), ( ) const, - (unsigned int), unsigned_int - ) - - // Test new and delete operators with and without operator name. - BOOST_CONTRACT_TEST_( - (void*), operator new, ( ), - (new), new - ) - BOOST_CONTRACT_TEST_( - (void*), operator(new)(new_ptr), ( ), - (new), new_ptr - ) - BOOST_CONTRACT_TEST_( - void, operator delete, ( ), - (delete), delete - ) - BOOST_CONTRACT_TEST_( - void, operator(delete)(delete_ptr), ( ), - (delete), delete_ptr - ) - - return BOOST_CONTRACT_TEST_AUX_PP_TRAITS_REPORT_ERRORS; -} - -#endif // variadics - diff --git a/test/pp_func_traits/params.cpp b/test/pp_func_traits/params.cpp deleted file mode 100644 index 6dab193..0000000 --- a/test/pp_func_traits/params.cpp +++ /dev/null @@ -1,114 +0,0 @@ - -#include -#if !BOOST_PP_VARIADICS -# error "this compiler does not support variadic macros" -#else - -#include -#define BOOST_CONTRACT_EXT_PP_FUNC_TRAITS_AUX_INDEX_TEST \ - BOOST_CONTRACT_EXT_PP_TRAITS_AUX_INDEX_FUNC_PARAMS - -#include "../aux_/pp_traits.hpp" -#include "../aux_/pp_1tuple_rem.hpp" -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#define BOOST_CONTRACT_TEST_PARAM_(r, unused, i, param) \ - BOOST_PP_COMMA_IF(i) \ - BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_PARAM_TRAITS_TYPE(param)) \ - BOOST_CONTRACT_EXT_PP_PARAM_TRAITS_NAME(param) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_PARAM_TRAITS_DEFAULT(param)), \ - BOOST_PP_TUPLE_EAT(2) \ - , \ - BOOST_PP_TUPLE_REM(2) \ - )( \ - BOOST_PP_EMPTY(), \ - default BOOST_CONTRACT_TEST_AUX_PP_1TUPLE_REM( \ - BOOST_CONTRACT_EXT_PP_PARAM_TRAITS_DEFAULT(param)) \ - ) - -#define BOOST_CONTRACT_TEST_PARAMS_(func_traits) \ - ( \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_FUNC_TRAITS_PARAMS(func_traits)), \ - BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOR_EACH_I \ - )(BOOST_CONTRACT_TEST_PARAM_, ~, \ - BOOST_CONTRACT_EXT_PP_FUNC_TRAITS_PARAMS(func_traits)) \ - ) - -// Variadic to allow to specify empty params `( )`. -#define BOOST_CONTRACT_TEST_EQUAL_(params, parsed_params) \ - BOOST_CONTRACT_TEST_AUX_PP_TRAITS( \ - BOOST_CONTRACT_TEST_PARAMS_, \ - BOOST_CONTRACT_EXT_PP_FUNC_TRAITS_PARSE_D, \ - (std::map&) (f), \ - params, \ - const volatile, \ - parsed_params \ - ) - -#define BOOST_CONTRACT_TEST_(...) \ - BOOST_CONTRACT_TEST_EQUAL_( (__VA_ARGS__), (__VA_ARGS__) ) - -int main ( ) { - // Test empty and void. - BOOST_CONTRACT_TEST_( ) - BOOST_CONTRACT_TEST_EQUAL_( ( void ), ( ) ) - - // Test named. - BOOST_CONTRACT_TEST_( int x ) - // Test named with default. - BOOST_CONTRACT_TEST_( int x, default 123 ) - // Test unnamed. - BOOST_CONTRACT_TEST_( int ) - // Test unnamed with default. - BOOST_CONTRACT_TEST_( int, default 123 ) - - // Test named with parenthesis. - BOOST_CONTRACT_TEST_( (std::map&) y ) - // Test named with parenthesis and default. - BOOST_CONTRACT_TEST_( - (std::map&) y, default (pair::sizeof_first) - ) - // Test unnamed with parenthesis. - BOOST_CONTRACT_TEST_( (std::map&) ) - // Test unnamed with parenthesis and default. - BOOST_CONTRACT_TEST_( - (std::map&), default (pair::sizeof_first) - ) - - // Test named arity. - BOOST_CONTRACT_TEST_( int x, (std::map&) y ) - // Test named arity with default. - BOOST_CONTRACT_TEST_( - int x, default 123, - (std::map&) y, default (pair::sizeof_first) - ) - // Test unnamed arity. - BOOST_CONTRACT_TEST_( int, (std::map&) ) - // Test unnamed arity with default. - BOOST_CONTRACT_TEST_( - int, default 123, - (std::map&), default (pair::sizeof_first) - ) - - // Test variadics. - BOOST_CONTRACT_TEST_EQUAL_( ( int count, (...) ), ( int count, ... ) ) - - return BOOST_CONTRACT_TEST_AUX_PP_TRAITS_REPORT_ERRORS; -} - -#endif // variadics - diff --git a/test/pp_func_traits/postconditions.cpp b/test/pp_func_traits/postconditions.cpp deleted file mode 100644 index 61030cb..0000000 --- a/test/pp_func_traits/postconditions.cpp +++ /dev/null @@ -1,76 +0,0 @@ - -#include -#if !BOOST_PP_VARIADICS -# error "this compiler does not support variadic macros" -#else - -#include -#define BOOST_CONTRACT_EXT_PP_FUNC_TRAITS_AUX_INDEX_TEST \ - BOOST_CONTRACT_EXT_PP_TRAITS_AUX_INDEX_FUNC_POSTCONDITIONS - -#include "../aux_/pp_traits.hpp" -#include "../aux_/pp_assertions.hpp" -#include -#include -#include -#include -#include -#include -#include -#include - -#define BOOST_CONTRACT_TEST_POSTCONDITIONS_(f) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_FUNC_TRAITS_POSTCONDITIONS(f)), \ - () BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT \ - )(BOOST_CONTRACT_TEST_AUX_PP_POST_ASSERTIONS_S_1, (), \ - BOOST_CONTRACT_EXT_PP_FUNC_TRAITS_POSTCONDITIONS(f)) - -#define BOOST_CONTRACT_TEST_EQUAL_(postconditions, parsed_postconditions) \ - BOOST_CONTRACT_TEST_AUX_PP_TRAITS( \ - BOOST_CONTRACT_TEST_POSTCONDITIONS_, \ - BOOST_CONTRACT_EXT_PP_FUNC_TRAITS_PARSE_D, \ - (std::map&) (f) ( ) throw(int, double) override final, \ - BOOST_PP_EXPR_IIF(BOOST_PP_COMPL( \ - BOOST_CONTRACT_EXT_PP_IS_EMPTY(postconditions)), \ - postcondition \ - ) \ - postconditions, \ - BOOST_PP_EMPTY(), \ - parsed_postconditions \ - ) - -#define BOOST_CONTRACT_TEST_(postconditions) \ - BOOST_CONTRACT_TEST_EQUAL_(postconditions, postconditions) - -#define oldof BOOST_CONTRACT_OLDOF - -int main ( ) { - #define BOOST_CONTRACT_TEST_ASSERTIONS_equal BOOST_CONTRACT_TEST_EQUAL_ - #define BOOST_CONTRACT_TEST_ASSERTIONS_check BOOST_CONTRACT_TEST_ - #define BOOST_CONTRACT_TEST_ASSERTIONS_post \ - auto result1 = return, \ - int const result2 = return, \ - (map const&) result3 = return, \ - \ - auto old_size = BOOST_CONTRACT_OLDOF v.size(), \ - unsigned int const old_capacity = oldof v.capacity(), \ - (map const) old_map = \ - BOOST_CONTRACT_OLDOF (map::clone(m)), - #define BOOST_CONTRACT_TEST_ASSERTIONS_post_if \ - auto c = return, \ - long long const d = BOOST_CONTRACT_OLDOF v.size(), - - #include "./assertions.hpp" // Include actual assertion tests. - - #undef BOOST_CONTRACT_TEST_ASSERTIONS_equal - #undef BOOST_CONTRACT_TEST_ASSERTIONS_check - #undef BOOST_CONTRACT_TEST_ASSERTIONS_post - #undef BOOST_CONTRACT_TEST_ASSERTIONS_post_if - return BOOST_CONTRACT_TEST_AUX_PP_TRAITS_REPORT_ERRORS; -} - -#endif // variadics - diff --git a/test/pp_func_traits/preconditions.cpp b/test/pp_func_traits/preconditions.cpp deleted file mode 100644 index 762b39b..0000000 --- a/test/pp_func_traits/preconditions.cpp +++ /dev/null @@ -1,64 +0,0 @@ - -#include -#if !BOOST_PP_VARIADICS -# error "this compiler does not support variadic macros" -#else - -#include -#define BOOST_CONTRACT_EXT_PP_FUNC_TRAITS_AUX_INDEX_TEST \ - BOOST_CONTRACT_EXT_PP_TRAITS_AUX_INDEX_FUNC_PRECONDITIONS - -#include "../aux_/pp_traits.hpp" -#include "../aux_/pp_assertions.hpp" -#include -#include -#include -#include -#include -#include -#include -#include - -#define BOOST_CONTRACT_TEST_PRECONDITIONS_(f) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY( \ - BOOST_CONTRACT_EXT_PP_FUNC_TRAITS_PRECONDITIONS(f)), \ - () BOOST_PP_TUPLE_EAT(3) \ - , \ - BOOST_PP_SEQ_FOLD_LEFT \ - )(BOOST_CONTRACT_TEST_AUX_PP_ASSERTIONS_S_1, (), \ - BOOST_CONTRACT_EXT_PP_FUNC_TRAITS_PRECONDITIONS(f)) - -#define BOOST_CONTRACT_TEST_EQUAL_(preconditions, parsed_preconditions) \ - BOOST_CONTRACT_TEST_AUX_PP_TRAITS( \ - BOOST_CONTRACT_TEST_PRECONDITIONS_, \ - BOOST_CONTRACT_EXT_PP_FUNC_TRAITS_PARSE_D, \ - (std::map&) (f) ( ) throw(int, double) override final, \ - BOOST_PP_EXPR_IIF(BOOST_PP_COMPL( \ - BOOST_CONTRACT_EXT_PP_IS_EMPTY(preconditions)), \ - precondition \ - ) \ - preconditions, \ - postcondition( auto result = return, result == x * x ), \ - parsed_preconditions \ - ) - -#define BOOST_CONTRACT_TEST_(preconditions) \ - BOOST_CONTRACT_TEST_EQUAL_(preconditions, preconditions) - -int main ( ) { - #define BOOST_CONTRACT_TEST_ASSERTIONS_equal BOOST_CONTRACT_TEST_EQUAL_ - #define BOOST_CONTRACT_TEST_ASSERTIONS_check BOOST_CONTRACT_TEST_ - #define BOOST_CONTRACT_TEST_ASSERTIONS_post - #define BOOST_CONTRACT_TEST_ASSERTIONS_post_if - - #include "./assertions.hpp" // Include actual assertion tests. - - #undef BOOST_CONTRACT_TEST_ASSERTIONS_equal - #undef BOOST_CONTRACT_TEST_ASSERTIONS_check - #undef BOOST_CONTRACT_TEST_ASSERTIONS_post - #undef BOOST_CONTRACT_TEST_ASSERTIONS_post_if - return BOOST_CONTRACT_TEST_AUX_PP_TRAITS_REPORT_ERRORS; -} - -#endif // variadics - diff --git a/test/pp_func_traits/ref.cpp b/test/pp_func_traits/ref.cpp deleted file mode 100644 index ab8f9ab..0000000 --- a/test/pp_func_traits/ref.cpp +++ /dev/null @@ -1,33 +0,0 @@ - -#include -#if !BOOST_PP_VARIADICS -# error "this compiler does not support variadic macros" -#else - -#include -#define BOOST_CONTRACT_EXT_PP_FUNC_TRAITS_AUX_INDEX_TEST \ - BOOST_CONTRACT_EXT_PP_TRAITS_AUX_INDEX_FUNC_REF - -#include "../aux_/pp_traits.hpp" -#include -#include - -#define BOOST_CONTRACT_TEST_(ref_) \ - BOOST_CONTRACT_TEST_AUX_PP_TRAITS( \ - BOOST_CONTRACT_EXT_PP_FUNC_TRAITS_REF, \ - BOOST_CONTRACT_EXT_PP_FUNC_TRAITS_PARSE_D, \ - (std::map&) (f) ( int x, (std::map&) y ) const, \ - ref_, \ - noexcept(my::map::key_size) final override, \ - ref_ \ - ) - -int main ( ) { - BOOST_CONTRACT_TEST_( BOOST_PP_EMPTY() ) - BOOST_CONTRACT_TEST_( ref ) - BOOST_CONTRACT_TEST_( ref ref ) - return BOOST_CONTRACT_TEST_AUX_PP_TRAITS_REPORT_ERRORS; -} - -#endif // variadics - diff --git a/test/pp_func_traits/return_.cpp b/test/pp_func_traits/return_.cpp deleted file mode 100644 index cab774d..0000000 --- a/test/pp_func_traits/return_.cpp +++ /dev/null @@ -1,96 +0,0 @@ - -#include -#if !BOOST_PP_VARIADICS -# error "this compiler does not support variadic macros" -#else - -#include -#define BOOST_CONTRACT_EXT_PP_FUNC_TRAITS_AUX_INDEX_TEST \ - BOOST_CONTRACT_EXT_PP_TRAITS_AUX_INDEX_FUNC_RETURN - -#include "../aux_/pp_traits.hpp" -#include -#include -#include -#include -#include -#include -#include - -// Wrap with parenthesis (if no parenthesis already and it is not `auto`). -// Precondition: return_ != EMPTY(). -#define BOOST_CONTRACT_TEST_PARENTHESIZE_(return_) \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_HAS_PAREN(return_), \ - BOOST_PP_TUPLE_REM(1) \ - , BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_KEYWORD_IS_AUTO_FRONT(return_), \ - BOOST_PP_TUPLE_REM(1) \ - , \ - BOOST_PP_EMPTY() \ - ))(return_) - -#define BOOST_CONTRACT_TEST_(before, return_, after) \ - BOOST_CONTRACT_TEST_AUX_PP_TRAITS( \ - BOOST_CONTRACT_EXT_PP_FUNC_TRAITS_RETURN, \ - BOOST_CONTRACT_EXT_PP_FUNC_TRAITS_PARSE_D, \ - before, \ - return_, \ - after, \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY(return_), \ - BOOST_PP_TUPLE_EAT(1) \ - , \ - BOOST_CONTRACT_TEST_PARENTHESIZE_ \ - )(return_) \ - ) - -int main ( ) { - // Return without and with parenthesis. - BOOST_CONTRACT_TEST_( - BOOST_PP_EMPTY(), - void, (f) ( ) - ) - BOOST_CONTRACT_TEST_( - BOOST_PP_EMPTY(), - (::std::map), (f) ( ) - ) - - // No return for constructor and destructor. - BOOST_CONTRACT_TEST_( - BOOST_PP_EMPTY(), - BOOST_PP_EMPTY(), (ctor) ( int x ) - ) - BOOST_CONTRACT_TEST_( - BOOST_PP_EMPTY(), - BOOST_PP_EMPTY(), (~dtor) ( ) - ) - - // No return for type conversion operators (with and without paren). - BOOST_CONTRACT_TEST_( - BOOST_PP_EMPTY(), - BOOST_PP_EMPTY(), operator int ( ) - ) - BOOST_CONTRACT_TEST_( - BOOST_PP_EMPTY(), - BOOST_PP_EMPTY(), operator(int*)(int_ptr) ( ) - ) - - // Return for other operators (non type conversions, etc.). - BOOST_CONTRACT_TEST_( - BOOST_PP_EMPTY(), - int, operator(+)(add) ( int, int ) - ) - BOOST_CONTRACT_TEST_( - BOOST_PP_EMPTY(), - (::std::map&), operator(*)(deref) ( ) - ) - - // Return for unified syntax. - BOOST_CONTRACT_TEST_( - template( typename L, typename R ), - auto, (add) ( (L) left, (R) right ) return decltype(left + right) - ) - - return BOOST_CONTRACT_TEST_AUX_PP_TRAITS_REPORT_ERRORS; -} - -#endif // variadics - diff --git a/test/pp_func_traits/template.cpp b/test/pp_func_traits/template.cpp deleted file mode 100644 index 566d37d..0000000 --- a/test/pp_func_traits/template.cpp +++ /dev/null @@ -1,39 +0,0 @@ - -#include -#if !BOOST_PP_VARIADICS -# error "this compiler does not support variadic macros" -#else - -#include -#define BOOST_CONTRACT_EXT_PP_FUNC_TRAITS_AUX_INDEX_TEST \ - BOOST_CONTRACT_EXT_PP_TRAITS_AUX_INDEX_FUNC_TEMPLATE - -#include "../aux_/pp_traits.hpp" -#include -#include - -#define BOOST_CONTRACT_TEST_TEMPLATE_(func_traits) \ - BOOST_CONTRACT_TEST_AUX_PP_TEMPLATE( \ - BOOST_CONTRACT_EXT_PP_FUNC_TRAITS_TEMPLATE(func_traits), \ - BOOST_CONTRACT_EXT_PP_FUNC_TRAITS_TEMPLATE_PARAMS(func_traits) \ - ) - -#define BOOST_CONTRACT_TEST_AUX_PP_TEMPLATE_CHECK(template_params) \ - BOOST_CONTRACT_TEST_AUX_PP_TRAITS( \ - BOOST_CONTRACT_TEST_TEMPLATE_, \ - BOOST_CONTRACT_EXT_PP_FUNC_TRAITS_PARSE_D, \ - BOOST_PP_EMPTY(), \ - template_params, \ - (std::map&) (f) ( int x, (std::map&) y ), \ - template_params \ - ) - -#include "../aux_/pp_template.hpp" - -int main ( ) { - boost::contract::test::aux::pp_template(); - return BOOST_CONTRACT_TEST_AUX_PP_TRAITS_REPORT_ERRORS; -} - -#endif // variadics - diff --git a/test/pp_func_traits/trailing_return.cpp b/test/pp_func_traits/trailing_return.cpp deleted file mode 100644 index b9582dd..0000000 --- a/test/pp_func_traits/trailing_return.cpp +++ /dev/null @@ -1,81 +0,0 @@ - -#include -#if !BOOST_PP_VARIADICS -# error "this compiler does not support variadic macros" -#else - -#include -#define BOOST_CONTRACT_EXT_PP_FUNC_TRAITS_AUX_INDEX_TEST \ - BOOST_CONTRACT_EXT_PP_TRAITS_AUX_INDEX_FUNC_TRAILING_RETURN - -#include "../aux_/pp_traits.hpp" -#include -#include -#include -#include -#include -#include -#include - -// Wrap with parenthesis (if no parenthesis already). -// Precondition: trailing_return != EMPTY(). -#define BOOST_CONTRACT_TEST_PARENTHESIZE_(trailing_return) \ - BOOST_PP_IIF( \ - BOOST_CONTRACT_EXT_PP_HAS_PAREN( \ - BOOST_CONTRACT_EXT_PP_KEYWORD_RETURN_REMOVE_FRONT(trailing_return) \ - ) \ - , \ - BOOST_PP_TUPLE_REM(1) \ - , \ - BOOST_PP_EMPTY() \ - )(BOOST_CONTRACT_EXT_PP_KEYWORD_RETURN_REMOVE_FRONT(trailing_return)) - -#define BOOST_CONTRACT_TEST_(before, trailing_return, after) \ - BOOST_CONTRACT_TEST_AUX_PP_TRAITS( \ - BOOST_CONTRACT_EXT_PP_FUNC_TRAITS_TRAILING_RETURN, \ - BOOST_CONTRACT_EXT_PP_FUNC_TRAITS_PARSE_D, \ - before, \ - trailing_return, \ - after, \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY(trailing_return), \ - BOOST_PP_TUPLE_EAT(1) \ - , \ - BOOST_CONTRACT_TEST_PARENTHESIZE_ \ - )(trailing_return) \ - ) - -int main ( ) { - // No trailing return. - BOOST_CONTRACT_TEST_( - void (f) ( ), BOOST_PP_EMPTY(), final override - ) - - // Trailing return with decltype. - BOOST_CONTRACT_TEST_( - template( typename L, typename R ) - auto (add) ( (L) left, (R) right ), return decltype(left + right), - final override - ) - // Trailing return with decltype and commas. - BOOST_CONTRACT_TEST_( - auto (f) ( ), return decltype(std::map()), final override - ) - - // Trailing return without parenthesis. - BOOST_CONTRACT_TEST_( - auto (f) ( ), return int const, final override - ) - // Trailing return with parenthesis. - BOOST_CONTRACT_TEST_( - auto (f) ( ), return (std::ostream&), final override - ) - // Trailing return with parenthesis and commas. - BOOST_CONTRACT_TEST_( - auto (f) ( ), return (std::map), final override - ) - - return BOOST_CONTRACT_TEST_AUX_PP_TRAITS_REPORT_ERRORS; -} - -#endif // variadics - diff --git a/test/pp_func_traits/verbatim.cpp b/test/pp_func_traits/verbatim.cpp deleted file mode 100644 index 7982cda..0000000 --- a/test/pp_func_traits/verbatim.cpp +++ /dev/null @@ -1,41 +0,0 @@ - -#include -#if !BOOST_PP_VARIADICS -# error "this compiler does not support variadic macros" -#else - -#include -#define BOOST_CONTRACT_EXT_PP_FUNC_TRAITS_AUX_INDEX_TEST \ - BOOST_CONTRACT_EXT_PP_TRAITS_AUX_INDEX_FUNC_VERBATIM - -#include "../aux_/pp_traits.hpp" -#include -#include -#include -#include -#include -#include - -#define BOOST_CONTRACT_TEST_AUX_PP_VERBATIM_CHECK(verbatim) \ - BOOST_CONTRACT_TEST_AUX_PP_TRAITS( \ - BOOST_CONTRACT_EXT_PP_FUNC_TRAITS_VERBATIM, \ - BOOST_CONTRACT_EXT_PP_FUNC_TRAITS_PARSE_D, \ - BOOST_PP_EMPTY(), \ - verbatim, \ - (std::map&) (f) ( int x, (std::map&) y ), \ - BOOST_PP_IIF(BOOST_CONTRACT_EXT_PP_IS_EMPTY(verbatim), \ - BOOST_PP_TUPLE_EAT(1) \ - , \ - BOOST_CONTRACT_EXT_PP_KEYWORD_VERBATIM_REMOVE_FRONT \ - )(verbatim) \ - ) - -#include "../aux_/pp_verbatim.hpp" - -int main ( ) { - boost::contract::test::aux::pp_verbatim(); - return BOOST_CONTRACT_TEST_AUX_PP_TRAITS_REPORT_ERRORS; -} - -#endif // variadics - diff --git a/test/pp_func_traits/virt.cpp b/test/pp_func_traits/virt.cpp deleted file mode 100644 index 138c9f3..0000000 --- a/test/pp_func_traits/virt.cpp +++ /dev/null @@ -1,47 +0,0 @@ - -#include -#if !BOOST_PP_VARIADICS -# error "this compiler does not support variadic macros" -#else - -#include -#define BOOST_CONTRACT_EXT_PP_FUNC_TRAITS_AUX_INDEX_TEST \ - BOOST_CONTRACT_EXT_PP_TRAITS_AUX_INDEX_FUNC_VIRT - -#include "../aux_/pp_traits.hpp" -#include -#include - -#define BOOST_CONTRACT_TEST_VIRT_(func_traits) \ - BOOST_CONTRACT_EXT_PP_FUNC_TRAITS_FINAL(func_traits) \ - BOOST_CONTRACT_EXT_PP_FUNC_TRAITS_OVERRIDE(func_traits) - -#define BOOST_CONTRACT_TEST_EQUAL_(virt, parsed_virt) \ - BOOST_CONTRACT_TEST_AUX_PP_TRAITS( \ - BOOST_CONTRACT_TEST_VIRT_, \ - BOOST_CONTRACT_EXT_PP_FUNC_TRAITS_PARSE_D, \ - (std::map&) (f) ( int x, (std::map&) y ) \ - throw(int, double), \ - virt, \ - precondition(x >= 0) postcondition(x == 0 ? y.empty() : true), \ - parsed_virt \ - ) - -#define BOOST_CONTRACT_TEST_(virt) \ - BOOST_CONTRACT_TEST_EQUAL_(virt, virt) - -int main ( ) { - BOOST_CONTRACT_TEST_( BOOST_PP_EMPTY() ) - - BOOST_CONTRACT_TEST_( final ) - BOOST_CONTRACT_TEST_( override ) - - BOOST_CONTRACT_TEST_( final override ) - // Same as `final override` once parsed (this order does not matter in C++). - BOOST_CONTRACT_TEST_EQUAL_( override final, final override ) - - return BOOST_CONTRACT_TEST_AUX_PP_TRAITS_REPORT_ERRORS; -} - -#endif // variadics - diff --git a/test/public_member_bases_static.cpp b/test/public_member_bases_static.cpp new file mode 100644 index 0000000..1b41f66 --- /dev/null +++ b/test/public_member_bases_static.cpp @@ -0,0 +1,93 @@ + +#include "aux_/oteststream.hpp" +#include +#include +#include +#include + +boost::contract::aux::test::oteststream out; + +struct b { + void invariant() const { + out << "b::inv" << std::endl; + } + + static void static_invariant() { + out << "b::static_inv" << std::endl; + } + + static void s() { + boost::contract::type c = boost::contract::public_member() + .precondition([&] () { + out << "b::s::pre" << std::endl; + }) + .postcondition([&] () { + out << "b::s::post" << std::endl; + }) + ; + out << "b::s::body" << std::endl; + } +}; + + +struct a + // Test base has no effect (because: static => no object => substitution + // principle does not apply => no subcontracting). + #define BASES public b + : BASES +{ + typedef BOOST_CONTRACT_BASE_TYPES(BASES) base_types; + #undef BASES + + void invariant() const { + out << "a::inv" << std::endl; + } + + static void static_invariant() { + out << "a::static_inv" << std::endl; + } + + static void s() { + boost::contract::type c = boost::contract::public_member() + .precondition([&] () { + out << "a::s::pre" << std::endl; + }) + .postcondition([&] () { + out << "a::s::post" << std::endl; + }) + ; + out << "a::s::body" << std::endl; + } +}; + +int main() { + std::ostringstream ok; + + out.str(""); + b::s(); // Test static call directly from class (no object). + ok.str(""); + ok + << "b::static_inv" << std::endl + << "b::s::pre" << std::endl + << "b::s::body" << std::endl + << "b::static_inv" << std::endl + << "b::s::post" << std::endl + ; + BOOST_TEST(out.check(ok.str())); + + a aa; + out.str(""); + aa.s(); // Test static call from object (and of derived class). + ok.str(""); + ok + << "a::static_inv" << std::endl + << "a::s::pre" << std::endl + << "a::s::body" << std::endl + << "a::static_inv" << std::endl + << "a::s::post" << std::endl + ; + BOOST_TEST(out.check(ok.str())); + + return boost::report_errors(); +} + diff --git a/test/public_member_bases_v.cpp b/test/public_member_bases_v.cpp deleted file mode 100644 index a500294..0000000 --- a/test/public_member_bases_v.cpp +++ /dev/null @@ -1,185 +0,0 @@ - -#include -#include -#include -#include -#include -#include - -// Test public members of classes with bases and with virtual bodies. - -std::ostringstream out; - -//// Test inheritance level 1 and no multiple inheritance. -//template< typename T > -//struct e { -// void invariant ( ) const { -// out << "e::inv" << std::endl; -// BOOST_CONTRACT_ASSERT(true); -// } -// -// // Test contract allows (but does not require) extra introspection, -// // function pointer, etc. parameter because class has no bases. -// void f ( T& x, boost::contract::virtual_body v = 0 ) { -// boost::contract::type contract = boost::contract::function< -// introspect_f>(this, &e::f, x, v) -// .precondition([&] ( ) { -// out << "e::f::pre" << std::endl; -// BOOST_CONTRACT_ASSERT(false); -// }) -// .postcondition([&] ( ) { -// out << "e::f::post" << std::endl; -// BOOST_CONTRACT_ASSERT(true); -// }) -// ; -// f_body(x); -// } -// virtual void f_body ( T& x ) = 0; -// -//private: -// BOOST_CONTRACT_INTROSPECT(f) -//}; -// -//// Test inheritance level 1 and no multiple inheritance. -//template< typename T > -//struct d { -// void invariant ( ) const { -// out << "d::inv" << std::endl; -// BOOST_CONTRACT_ASSERT(true); -// } -// -// // Test contract does not require (but allows) extra introspection, -// // function pointer, etc. parameter because class has no bases. -// void f ( T& x, boost::contract::virtual_body v = 0 ) { -// boost::contract::type contract = boost::contract::function(this, v) -// .precondition([&] ( ) { -// out << "d::f::pre" << std::endl; -// BOOST_CONTRACT_ASSERT(false); -// }) -// .postcondition([&] ( ) { -// out << "d::f::post" << std::endl; -// BOOST_CONTRACT_ASSERT(true); -// }) -// ; -// f_body(x); -// } -// virtual void f_body ( T& x ) = 0; -//}; - -// Test inheritance level 2 and multiple inheritance 2 (both contracted bases). -#define BASES e, d -template -struct c {//: BASES { -// typedef BOOST_CONTRACT_BASE_TYPES(BASES) base_types; -# undef BASES - - void invariant() const { - out << "c::inv" << std::endl; - BOOST_CONTRACT_ASSERT(true); - } - - virtual ~c() {} - - // Test virtual overrides virtual function. - void f(T& x, boost::contract::virtual_body v = 0) { - boost::contract::type contract = boost::contract::public_member< - introspect_f>(this, &c::f, x, v) - .precondition([&] () { - out << "c::f::pre" << std::endl; - BOOST_CONTRACT_ASSERT(false); - }) - .postcondition([&] () { - out << "c::f::post" << std::endl; - BOOST_CONTRACT_ASSERT(true); - }) - ; - f_body(x); - } - virtual void f_body(T& x) {} - - // Test non-contracted virtual function in contracted base. - virtual void k() = 0; - -private: - BOOST_CONTRACT_INTROSPECT(f) -}; - -// Test a non-contracted base. -template< class S > -struct b { - virtual ~b ( ) {} - virtual void g ( ) = 0; - virtual void h ( ) {} -}; - -// Test inheritance level 3 and multiple inheritance 2 (one contracted base, -// and one not). -#define BASES public c, private b -template -struct a : BASES { - typedef BOOST_CONTRACT_BASE_TYPES(BASES) base_types; -# undef BASES - - void invariant() const { - out << "a::inv" << std::endl; - BOOST_CONTRACT_ASSERT(true); - } - - // Test non-virtual overrides virtual function. - void f(T& x) { - boost::contract::type contract = boost::contract::public_member< - introspect_f>(this, &a::f, x) - .precondition([&] () { - out << "a::f::pre" << std::endl; - BOOST_CONTRACT_ASSERT(true); - }) - .postcondition([&] () { - out << "a::f::post" << std::endl; - BOOST_CONTRACT_ASSERT(true); - }) - ; - f_body(x); - } - void f_body(T& x) { out << "a::f::body" << std::endl; } - - void k() {} - -private: - void g() {} - - BOOST_CONTRACT_INTROSPECT(f) -}; - -int main() { - std::ostringstream ok; - - a aa; - int x = 123; - - out << std::endl; - aa.f(x); - ok << std::endl - << "e::inv" << std::endl - << "d::inv" << std::endl - << "c::inv" << std::endl - << "a::inv" << std::endl - << "e::f::pre" << std::endl - << "d::f::pre" << std::endl - << "c::f::pre" << std::endl - << "a::f::pre" << std::endl - << "a::f::body" << std::endl - << "e::inv" << std::endl - << "d::inv" << std::endl - << "c::inv" << std::endl - << "a::inv" << std::endl - << "e::f::post" << std::endl - << "d::f::post" << std::endl - << "c::f::post" << std::endl - << "a::f::post" << std::endl - ; - std::cout << out.str() << std::endl; - //BOOST_TEST_EQ(out.str(), ok.str()); - - return boost::report_errors(); -} - diff --git a/test/public_member_bases_virtual.cpp b/test/public_member_bases_virtual.cpp new file mode 100644 index 0000000..696efc3 --- /dev/null +++ b/test/public_member_bases_virtual.cpp @@ -0,0 +1,216 @@ + +#include "aux_/oteststream.hpp" +#include +#include +#include +#include +#include +#include + +// Test public member contracts for classes with and without bases, with and +// without virtual bodies. + +boost::contract::aux::test::oteststream out; + +// Test inheritance level 0 (no bases). +template +struct e { + void invariant() const { + out << "e::inv" << std::endl; + } + + static void static_invariant() { + out << "e::static_inv" << std::endl; + } + + virtual ~e() {} + + // Test contract allows (but does not require) extra introspection, + // function pointer, etc. parameter because class has no bases. + void f(T& x, boost::contract::virtual_body v = 0) { + boost::contract::type c = boost::contract::public_member( + this, &e::f, x, v) + .precondition([&]() { + out << "e::f::pre" << std::endl; + BOOST_CONTRACT_ASSERT(false); // To check subcontracted pre. + }) + .postcondition([&]() { + out << "e::f::post" << std::endl; + }) + ; + f_body(x); + } + virtual void f_body(T& x) = 0; + +private: + BOOST_CONTRACT_INTROSPECT(f) +}; + +// Test inheritance level 0 (no bases). +template +struct d { + void invariant() const { + out << "d::inv" << std::endl; + } + + static void static_invariant() { + out << "d::static_inv" << std::endl; + } + + virtual ~d() {} + + // Test contract does not require (but allows) extra introspection, + // function pointer, etc. parameter because class has no bases. + void f(T& x, boost::contract::virtual_body v = 0) { + boost::contract::type c = boost::contract::public_member(this, v) + .precondition([&]() { + out << "d::f::pre" << std::endl; + BOOST_CONTRACT_ASSERT(false); // To check subcontracted pre. + }) + .postcondition([&]() { + out << "d::f::post" << std::endl; + }) + ; + f_body(x); + } + virtual void f_body(T& x) = 0; +}; + +// Test inheritance level 1 and multiple inheritance (both contracted bases). +template +struct c + #define BASES public e, public d + : BASES +{ + typedef BOOST_CONTRACT_BASE_TYPES(BASES) base_types; + #undef BASES + + void invariant() const { + out << "c::inv" << std::endl; + } + + static void static_invariant() { + out << "c::static_inv" << std::endl; + } + + virtual ~c() {} + + // Test virtual overrides virtual function. + void f(T& x, boost::contract::virtual_body v = 0) { + boost::contract::type c = boost::contract::public_member( + this, &c::f, x, v) + .precondition([&]() { + out << "c::f::pre" << std::endl; + BOOST_CONTRACT_ASSERT(false); // To check subcontracted pre. + }) + .postcondition([&]() { + out << "c::f::post" << std::endl; + }) + ; + f_body(x); + } + virtual void f_body(T& x) {} + + // Test non-contracted virtual function in contracted base. + virtual void k() = 0; + +private: + BOOST_CONTRACT_INTROSPECT(f) +}; + +// Test a non-contracted base. +template +struct b { + virtual ~b() {} + virtual void g() = 0; + virtual void h() {} +}; + +// Test inheritance level 2 and multiple inheritance (one contracted base, +// and one not). +template +struct a + #define BASES public c, public b + : BASES +{ + typedef BOOST_CONTRACT_BASE_TYPES(BASES) base_types; + #undef BASES + + void invariant() const { + out << "a::inv" << std::endl; + } + + static void static_invariant() { + out << "a::static_inv" << std::endl; + } + + virtual ~a() {} + + // Test non-virtual overrides virtual function. + void f(T& x) { + boost::contract::type c = boost::contract::public_member( + this, &a::f, x) + .precondition([&]() { + out << "a::f::pre" << std::endl; + }) + .postcondition([&]() { + out << "a::f::post" << std::endl; + }) + ; + f_body(x); + } + void f_body(T& x) { out << "a::f::body" << std::endl; } + + void k() {} + +private: + void g() {} + + BOOST_CONTRACT_INTROSPECT(f) +}; + +int main() { + std::ostringstream ok; + + a aa; + int x = 123; + + out.str(""); + aa.f(x); + ok.str(""); + ok + << "e::static_inv" << std::endl + << "e::inv" << std::endl + << "d::static_inv" << std::endl + << "d::inv" << std::endl + << "c::static_inv" << std::endl + << "c::inv" << std::endl + << "a::static_inv" << std::endl + << "a::inv" << std::endl + + << "e::f::pre" << std::endl + << "d::f::pre" << std::endl + << "c::f::pre" << std::endl + << "a::f::pre" << std::endl + + << "a::f::body" << std::endl + + << "e::static_inv" << std::endl + << "e::inv" << std::endl + << "d::static_inv" << std::endl + << "d::inv" << std::endl + << "c::static_inv" << std::endl + << "c::inv" << std::endl + << "a::static_inv" << std::endl + << "a::inv" << std::endl + + << "e::f::post" << std::endl + << "d::f::post" << std::endl + << "c::f::post" << std::endl + << "a::f::post" << std::endl + ; + BOOST_TEST(out.check(ok.str())); + + return boost::report_errors(); +} + diff --git a/test/subcontracting/inheritance_level3_multi2.cpp b/test/subcontracting/inheritance_level3_multi2.cpp deleted file mode 100644 index 66421d6..0000000 --- a/test/subcontracting/inheritance_level3_multi2.cpp +++ /dev/null @@ -1,179 +0,0 @@ - -#include -#include -#include - -std::ostringstream out; - -// Test inheritance level 1 and no multiple inheritance. -template< typename T > -struct e { - void invariant ( ) const { - out << "e::inv" << std::endl; - BOOST_CONTRACT_ASSERT(true); - } - - // Test contract allows (but does not require) extra introspection, - // function pointer, etc. parameter because class has no bases. - void f ( T& x, boost::contract::virtual_body v = 0 ) { - boost::contract::type contract = boost::contract::function< - introspect_f>(this, &e::f, x, v) - .precondition([&] ( ) { - out << "e::f::pre" << std::endl; - BOOST_CONTRACT_ASSERT(false); - }) - .postcondition([&] ( ) { - out << "e::f::post" << std::endl; - BOOST_CONTRACT_ASSERT(true); - }) - ; - f_body(x); - } - virtual void f_body ( T& x ) = 0; - -private: - BOOST_CONTRACT_INTROSPECT(f) -}; - -// Test inheritance level 1 and no multiple inheritance. -template< typename T > -struct d { - void invariant ( ) const { - out << "d::inv" << std::endl; - BOOST_CONTRACT_ASSERT(true); - } - - // Test contract does not require (but allows) extra introspection, - // function pointer, etc. parameter because class has no bases. - void f ( T& x, boost::contract::virtual_body v = 0 ) { - boost::contract::type contract = boost::contract::function(this, v) - .precondition([&] ( ) { - out << "d::f::pre" << std::endl; - BOOST_CONTRACT_ASSERT(false); - }) - .postcondition([&] ( ) { - out << "d::f::post" << std::endl; - BOOST_CONTRACT_ASSERT(true); - }) - ; - f_body(x); - } - virtual void f_body ( T& x ) = 0; -}; - -// Test inheritance level 2 and multiple inheritance 2 (both contracted bases). -#define BASES e, d -template< typename T, class S > -struct c : BASES { - typedef BOOST_CONTRACT_BASE_TYPES(BASES) base_types; -# undef BASES - - void invariant ( ) const { - out << "c::inv" << std::endl; - BOOST_CONTRACT_ASSERT(true); - } - - virtual ~c ( ) {} - - // Test virtual overrides virtual function. - void f ( T& x, boost::contract::virtual_body v = 0 ) { - boost::contract::type contract = boost::contract::function< - introspect_f>(this, &c::f, x, v) - .precondition([&] ( ) { - out << "c::f::pre" << std::endl; - BOOST_CONTRACT_ASSERT(false); - }) - .postcondition([&] ( ) { - out << "c::f::post" << std::endl; - BOOST_CONTRACT_ASSERT(true); - }) - ; - f_body(x); - } - virtual void f_body ( T& x ) {} - - // Test non-contracted virtual function in contracted base. - virtual void k ( ) = 0; - -private: - BOOST_CONTRACT_INTROSPECT(f) -}; - -// Test a non-contracted base. -template< class S > -struct b { - virtual ~b ( ) {} - virtual void g ( ) = 0; - virtual void h ( ) {} -}; - -// Test inheritance level 3 and multiple inheritance 2 (one contracted base, -// and one not). -#define BASES public c, private b -template< typename T, class S = unsigned int > -struct a : BASES { - typedef BOOST_CONTRACT_BASE_TYPES(BASES) base_types; -# undef BASES - - void invariant ( ) const { - out << "a::inv" << std::endl; - BOOST_CONTRACT_ASSERT(true); - } - - // Test non-virtual overrides virtual function. - void f ( T& x ) { - boost::contract::type contract = boost::contract::function< - introspect_f>(this, &a::f, x) - .precondition([&] ( ) { - out << "a::f::pre" << std::endl; - BOOST_CONTRACT_ASSERT(true); - }) - .postcondition([&] ( ) { - out << "a::f::post" << std::endl; - BOOST_CONTRACT_ASSERT(true); - }) - ; - f_body(x); - } - void f_body ( T& x ) { out << "a::f::body" << std::endl; } - - void k ( ) {} - -private: - void g ( ) {} - - BOOST_CONTRACT_INTROSPECT(f) -}; - -int main ( ) { - std::ostringstream ok; - - a aa; - int x = 123; - - out << std::endl; - aa.f(x); - ok << std::endl - << "e::inv" << std::endl - << "d::inv" << std::endl - << "c::inv" << std::endl - << "a::inv" << std::endl - << "e::f::pre" << std::endl - << "d::f::pre" << std::endl - << "c::f::pre" << std::endl - << "a::f::pre" << std::endl - << "a::f::body" << std::endl - << "e::inv" << std::endl - << "d::inv" << std::endl - << "c::inv" << std::endl - << "a::inv" << std::endl - << "e::f::post" << std::endl - << "d::f::post" << std::endl - << "c::f::post" << std::endl - << "a::f::post" << std::endl - ; - BOOST_TEST_EQ(out.str(), ok.str()); - - return boost::report_errors(); -} -