boost/contract_macro.hpp
#ifndef BOOST_CONTRACT_MACRO_HPP_ #define BOOST_CONTRACT_MACRO_HPP_ // Copyright (C) 2008-2018 Lorenzo Caminiti // Distributed under the Boost Software License, Version 1.0 (see accompanying // file LICENSE_1_0.txt or a copy at http://www.boost.org/LICENSE_1_0.txt). // See: http://www.boost.org/doc/libs/release/libs/contract/doc/html/index.html /** @file Allow to disable contracts to completely remove their compile-time and run-time overhead. This header automatically includes all header files <c>boost/contract/\*.hpp</c> necessary to use its macros. Almost all the macros defined in this header file are variadic macros. On compilers that do not support variadic macros, programmers can manually code <c>\#ifndef BOOST_CONTRACT_NO_...</c> statements instead (see @RefSect{extras.disable_contract_compilation__macro_interface_, Disable Contract Compilation}). */ // IMPORTANT: Following headers can always be #included (without any #if-guard) // because they expand to trivial code that does not affect compile-time. These // headers must always be #included here (without any #if-guard) because they // define types and macros that are typically left in user code even when // contracts are disables (these types and macros never affect run-time and // their definitions are trivial when contracts are disabled so their impact on // compile-time is negligible). #include <boost/contract/override.hpp> #include <boost/contract/base_types.hpp> #include <boost/contract/core/constructor_precondition.hpp> #include <boost/contract/core/check_macro.hpp> #include <boost/contract/core/access.hpp> #include <boost/contract/core/virtual.hpp> #include <boost/contract/core/exception.hpp> #include <boost/contract/core/config.hpp> #ifndef BOOST_CONTRACT_NO_CONDITIONS #include <boost/contract/assert.hpp> #endif #ifdef BOOST_CONTRACT_DETAIL_DOXYGEN /** Program preconditions that can be completely disabled at compile-time. @c BOOST_CONTRACT_PRECONDITION(f) expands to code equivalent to the following (note that no code is generated when @RefMacro{BOOST_CONTRACT_NO_PRECONDITIONS} is defined): @code #ifndef BOOST_CONTRACT_NO_PRECONDITIONS .precondition(f) #endif @endcode Where: @arg <c><b>f</b></c> is the nullay functor called by this library to check preconditions @c f(). Assertions within this functor are usually programmed using @RefMacro{BOOST_CONTRACT_ASSERT}, but any exception thrown by a call to this functor indicates a contract assertion failure (and will result in this library calling @RefFunc{boost::contract::precondition_failure}). This functor should capture variables by (constant) value, or better by (constant) reference (to avoid extra copies). (This is a variadic macro parameter so it can contain commas not protected by round parenthesis.) @see @RefSect{extras.disable_contract_compilation__macro_interface_, Disable Contract Compilation}, @RefSect{tutorial.preconditions, Preconditions} */ #define BOOST_CONTRACT_PRECONDITION(...) #elif !defined(BOOST_CONTRACT_NO_PRECONDITIONS) #define BOOST_CONTRACT_PRECONDITION(...) .precondition(__VA_ARGS__) #else #define BOOST_CONTRACT_PRECONDITION(...) /* nothing */ #endif #ifdef BOOST_CONTRACT_DETAIL_DOXYGEN /** Program postconditions that can be completely disabled at compile-time. @c BOOST_CONTRACT_POSTCONDITION(f) expands to code equivalent to the following (note that no code is generated when @RefMacro{BOOST_CONTRACT_NO_POSTCONDITIONS} is defined): @code #ifndef BOOST_CONTRACT_NO_POSTCONDITIONS .postcondition(f) #endif @endcode Where: @arg <c><b>f</b></c> is the functor called by this library to check postconditions @c f() or @c f(result). Assertions within this functor are usually programmed using @RefMacro{BOOST_CONTRACT_ASSERT}, but any exception thrown by a call to this functor indicates a contract assertion failure (and will result in this library calling @RefFunc{boost::contract::postcondition_failure}). This functor should capture variables by (constant) references (to access the values they will have at function exit). This functor takes the return value (preferably by <c>const&</c>) @c result as its one single parameter @c f(result) but only for virtual public functions and public functions overrides, otherwise it takes no parameter @c f(). (This is a variadic macro parameter so it can contain commas not protected by round parenthesis.) @see @RefSect{extras.disable_contract_compilation__macro_interface_, Disable Contract Compilation}, @RefSect{tutorial.postconditions, Postconditions} */ #define BOOST_CONTRACT_POSTCONDITION(...) #elif !defined(BOOST_CONTRACT_NO_POSTCONDITIONS) #define BOOST_CONTRACT_POSTCONDITION(...) .postcondition(__VA_ARGS__) #else #define BOOST_CONTRACT_POSTCONDITION(...) /* nothing */ #endif #ifdef BOOST_CONTRACT_DETAIL_DOXYGEN /** Program exception guarantees that can be completely disabled at compile-time. @c BOOST_CONTRACT_EXCEPT(f) expands to code equivalent to the following (note that no code is generated when @RefMacro{BOOST_CONTRACT_NO_EXCEPTS} is defined): @code #ifndef BOOST_CONTRACT_NO_EXCEPTS .except(f) #endif @endcode Where: @arg <c><b>f</b></c> is the nullary functor called by this library to check exception guarantees @c f(). Assertions within this functor are usually programmed using @RefMacro{BOOST_CONTRACT_ASSERT}, but any exception thrown by a call to this functor indicates a contract assertion failure (and will result in this library calling @RefFunc{boost::contract::except_failure}). This functor should capture variables by (constant) references (to access the values they will have at function exit). (This is a variadic macro parameter so it can contain commas not protected by round parenthesis.) @see @RefSect{extras.disable_contract_compilation__macro_interface_, Disable Contract Compilation}, @RefSect{tutorial.exception_guarantees, Exception Guarantees} */ #define BOOST_CONTRACT_EXCEPT(...) #elif !defined(BOOST_CONTRACT_NO_EXCEPTS) #define BOOST_CONTRACT_EXCEPT(...) .except(__VA_ARGS__) #else #define BOOST_CONTRACT_EXCEPT(...) /* nothing */ #endif #ifdef BOOST_CONTRACT_DETAIL_DOXYGEN /** Program old value copies at body that can be completely disabled at compile-time. @c BOOST_CONTRACT_OLD(f) expands to code equivalent to the following (note that no code is generated when @RefMacro{BOOST_CONTRACT_NO_OLDS} is defined): @code #ifndef BOOST_CONTRACT_NO_OLDS .old(f) #endif @endcode Where: @arg <c><b>f</b></c> is the nullary functor called by this library @c f() to assign old value copies just before the body is execute but after entry invariants (when they apply) and preconditions are checked. Old value pointers within this functor call are usually assigned using @RefMacro{BOOST_CONTRACT_OLDOF}. Any exception thrown by a call to this functor will result in this library calling @RefFunc{boost::contract::old_failure} (because old values could not be copied to check postconditions and exception guarantees). This functor should capture old value pointers by references so they can be assigned (all other variables needed to evaluate old value expressions can be captured by (constant) value, or better by (constant) reference to avoid extra copies). (This is a variadic macro parameter so it can contain commas not protected by round parenthesis.) @see @RefSect{extras.disable_contract_compilation__macro_interface_, Disable Contract Compilation}, @RefSect{advanced.old_values_copied_at_body, Old Values Copied at Body} */ #define BOOST_CONTRACT_OLD(...) /** Program old values that can be completely disabled at compile-time for old value types that are required to be copyable. This is used to program old value copies for copyable types: @code class u { public: void f(...) { BOOST_CONTRACT_OLD_PTR(old_type_a)(old_var_a); // Null... BOOST_CONTRACT_OLD_PTR(old_type_b)(old_var_b, old_expr_b); // Set. BOOST_CONTRACT_PUBLIC_FUNCTION(this) ... BOOST_CONTRACT_OLD([&] { old_var_a = BOOST_CONTRACT_OLDOF(old_expr_a); // ...set. ... }) ... ; ... // Function body. } virtual void g(..., boost::contract::virtual_* v = 0) { BOOST_CONTRACT_OLD_PTR(old_type_a)(old_var_a); // No `v` BOOST_CONTRACT_OLD_PTR(old_type_b)(v, old_var_b, old_expr_b); // `v` BOOST_CONTRACT_PUBLIC_FUNCTION(v, this) ... BOOST_CONTRACT_OLD([&] { old_var_a = BOOST_CONTRACT_OLDOF(v, old_expr_a); // `v` ... }) ... ; ... // Function body. } ... }; @endcode This is an overloaded variadic macro and it can be used in the following different ways (note that no code is generated when @RefMacro{BOOST_CONTRACT_NO_OLDS} is defined). 1\. <c>BOOST_CONTRACT_OLD_PTR(old_type)(old_var)</c> expands to code equivalent to the following (this leaves the old value pointer null): @code #ifndef BOOST_CONTRACT_NO_OLDS // This declaration does not need to use `v`. boost::contract::old_ptr<old_type> old_var #endif @endcode 2\. <c>BOOST_CONTRACT_OLD_PTR(old_type)(old_var, old_expr)</c> expands to code equivalent to the following (this initializes the pointer to the old value copy, but not to be used for virtual public functions and public function overrides): @code #ifndef BOOST_CONTRACT_NO_OLDS boost::contract::old_ptr<old_type> old_var = BOOST_CONTRACT_OLDOF(old_expr) #endif @endcode 3\. <c>BOOST_CONTRACT_OLD_PTR(old_type)(v, old_var, old_expr)</c> expands to code equivalent to the following (this initializes the pointer to the old value copy for virtual public functions and public function overrides): @code #ifndef BOOST_CONTRACT_NO_OLDS boost::contract::old_ptr<old_type> old_var = BOOST_CONTRACT_OLDOF(v, old_expr) #endif @endcode Where: @arg <c><b>old_type</b></c> is the type of the pointed old value. This type must be copyable (i.e., <c>boost::contract::is_old_value_copyable<old_type>::value</c> is @c true), otherwise this pointer will always be null and this library will generate a compile-time error when the pointer is dereferenced (see @RefMacro{BOOST_CONTRACT_OLD_PTR_IF_COPYABLE}). (This is a variadic macro parameter so it can contain commas not protected by round parenthesis.) (Rationale: Template parameters like this one are specified to this library macro interface using their own set of parenthesis <c>SOME_MACRO(template_params)(other_params)</c>.) @arg <c><b>v</b></c> is the extra training parameter of type @RefClass{boost::contract::virtual_}<c>*</c> and default value @c 0 from the enclosing virtual public function or public function override declaring the contract. (This is not a variadic macro parameter but it should never contain commas because it is an identifier.) @arg <c><b>old_var</b></c> is the name of the old value pointer variable. (This is not a variadic macro parameter but it should never contain commas because it is an identifier.) @arg <c><b>old_expr</b></c> is the expression to be evaluated and copied in the old value pointer. (This is not a variadic macro parameter so any comma it might contain must be protected by round parenthesis and <c>BOOST_CONTRACT_OLD_PTR(old_type)(v, old_var, (old_expr))</c> will always work.) @see @RefSect{extras.disable_contract_compilation__macro_interface_, Disable Contract Compilation}, @RefSect{tutorial.old_values, Old Values} */ #define BOOST_CONTRACT_OLD_PTR(...) /** Program old values that can be completely disabled at compile-time for old value types that are not required to be copyable. This is used to program old value copies for types that might or might not be copyable: @code template<typename T> // Type `T` might or not be copyable. class u { public: void f(...) { BOOST_CONTRACT_OLD_PTR_IF_COPYABLE(old_type_a)(old_var_a); BOOST_CONTRACT_OLD_PTR_IF_COPYABLE(old_type_b)(old_var_b, old_expr_b); BOOST_CONTRACT_PUBLIC_FUNCTION(this) ... BOOST_CONTRACT_OLD([&] { old_var_a = BOOST_CONTRACT_OLDOF(old_expr_a); ... }) ... // In postconditions or exception guarantees: if(old_var_a) ... // Always null for non-copyable types. if(old_var_b) ... // Always null for non-copyable types. ... ; ... // Function body. } virtual void g(..., boost::contract::virtual_* v = 0) { BOOST_CONTRACT_OLD_PTR_IF_COPYABLE(old_type_a)(old_var_a); BOOST_CONTRACT_OLD_PTR_IF_COPYABLE(old_type_b)(v, old_var_b, old_expr_b); BOOST_CONTRACT_PUBLIC_FUNCTION(v, this) ... BOOST_CONTRACT_OLD([&] { old_var_a = BOOST_CONTRACT_OLDOF(v, old_expr_a); ... }) ... // In postconditions or exception guarantees: if(old_var_a) ... // Always null for non-copyable types. if(old_var_b) ... // Always null for non-copyable types. ... ; ... // Function body. } ... }; @endcode This is an overloaded variadic macro and it can be used in the following different ways (note that no code is generated when @RefMacro{BOOST_CONTRACT_NO_OLDS} is defined). 1\. <c>BOOST_CONTRACT_OLD_PTR_IF_COPYABLE(old_type)(old_var)</c> expands to code equivalent to the following (this leaves the old value pointer null): @code #ifndef BOOST_CONTRACT_NO_OLDS // This declaration does not need to use `v`. boost::contract::old_ptr_if_copyable<old_type> old_var #endif @endcode 2\. <c>BOOST_CONTRACT_OLD_PTR_IF_COPYABLE(old_type)(old_var, old_expr)</c> expands to code equivalent to the following (this initializes the pointer to the old value copy, but not to be used for virtual public functions and public function overrides): @code #ifndef BOOST_CONTRACT_NO_OLDS boost::contract::old_ptr_if_copyable<old_type> old_var = BOOST_CONTRACT_OLDOF(old_expr) #endif @endcode 3\. <c>BOOST_CONTRACT_OLD_PTR_IF_COPYABLE(old_type)(v, old_var, old_expr)</c> expands to code equivalent to the following (this initializes the pointer to the old value copy for virtual public functions and public function overrides): @code #ifndef BOOST_CONTRACT_NO_OLDS boost::contract::old_ptr_if_copyable<old_type> old_var = BOOST_CONTRACT_OLDOF(v, old_expr) #endif @endcode Where: @arg <c><b>old_type</b></c> is the type of the pointed old value. If this type is not copyable (i.e., <c>boost::contract::is_old_value_copyable<old_type>::value</c> is @c false), this pointer will always be null, but this library will not generate a compile-time error when this pointer is dereferenced (see @RefMacro{BOOST_CONTRACT_OLD_PTR}). (This is a variadic macro parameter so it can contain commas not protected by round parenthesis.) @arg <c><b>v</b></c> is the extra trailing parameter of type @RefClass{boost::contract::virtual_}<c>*</c> and default value @c 0 from the enclosing virtual public function or public function override declaring the contract. (This is not a variadic macro parameter but it should never contain commas because it is an identifier.) @arg <c><b>old_var</b></c> is the name of the old value pointer variable. (This is not a variadic macro parameter but it should never contain commas because it is an identifier.) @arg <c><b>old_expr</b></c> is the expression to be evaluated and copied in the old value pointer. (This is not a variadic macro parameter so any comma it might contain must be protected by round parenthesis and <c>BOOST_CONTRACT_OLD_PTR_IF_COPYABLE(old_type)(v, old_var, (old_expr))</c> will always work.) @see @RefSect{extras.disable_contract_compilation__macro_interface_, Disable Contract Compilation}, @RefSect{extras.old_value_requirements__templates_, Old Value Requirements} */ #define BOOST_CONTRACT_OLD_PTR_IF_COPYABLE(...) #elif !defined(BOOST_CONTRACT_NO_OLDS) #include <boost/contract/old.hpp> #include <boost/preprocessor/facilities/overload.hpp> #include <boost/preprocessor/facilities/empty.hpp> #include <boost/preprocessor/cat.hpp> /* PRIVATE */ #define BOOST_CONTRACT_OLD_VAR_1(ptr) \ ptr #define BOOST_CONTRACT_OLD_VAR_2(ptr, expr) \ ptr = BOOST_CONTRACT_OLDOF(expr) #define BOOST_CONTRACT_OLD_VAR_3(v, ptr, expr) \ ptr = BOOST_CONTRACT_OLDOF(v, expr) #define BOOST_CONTRACT_OLD_VAR_(...) \ BOOST_PP_CAT(BOOST_PP_OVERLOAD(BOOST_CONTRACT_OLD_VAR_, __VA_ARGS__) \ (__VA_ARGS__), BOOST_PP_EMPTY()) /* PUBLIC */ #define BOOST_CONTRACT_OLD(...) .old(__VA_ARGS__) #define BOOST_CONTRACT_OLD_PTR(...) \ boost::contract::old_ptr< __VA_ARGS__ > \ BOOST_CONTRACT_OLD_VAR_ #define BOOST_CONTRACT_OLD_PTR_IF_COPYABLE(...) \ boost::contract::old_ptr_if_copyable< __VA_ARGS__ > \ BOOST_CONTRACT_OLD_VAR_ #else #include <boost/preprocessor/tuple/eat.hpp> #define BOOST_CONTRACT_OLD(...) /* nothing */ #define BOOST_CONTRACT_OLD_PTR(...) BOOST_PP_TUPLE_EAT(0) #define BOOST_CONTRACT_OLD_PTR_IF_COPYABLE(...) BOOST_PP_TUPLE_EAT(0) #endif #ifdef BOOST_CONTRACT_DETAIL_DOXYGEN /** Program (constant) class invariants that can be completely disabled at compile-time. @c BOOST_CONTRACT_INVARIANT({ ... }) expands to code equivalent to the following (note that no code is generated when @RefMacro{BOOST_CONTRACT_NO_INVARIANTS} is defined): @code #ifndef BOOST_CONTRACT_NO_INVARIANTS void BOOST_CONTRACT_INVARIANT_FUNC() const { ... } #endif @endcode Where: @arg <b>{ ... }</b> is the definition of the function that checks class invariants for public functions that are not static and not volatile (see @RefMacro{BOOST_CONTRACT_STATIC_INVARIANT} and @RefMacro{BOOST_CONTRACT_INVARIANT_VOLATILE}). The curly parenthesis are mandatory (rationale: this is so the syntax of this macro resembles mote the syntax of the lambda functions usually used to specify preconditions, etc.). Assertions within this function are usually programmed using @RefMacro{BOOST_CONTRACT_ASSERT}, but any exception thrown by a call to this function indicates a contract assertion failure (and will result in this library calling either @RefFunc{boost::contract::entry_invariant_failure} or @RefFunc{boost::contract::exit_invariant_failure}). (This is a variadic macro parameter so it can contain commas not protected by round parenthesis.) @see @RefSect{extras.disable_contract_compilation__macro_interface_, Disable Contract Compilation}, @RefSect{tutorial.class_invariants, Class Invariants} */ #define BOOST_CONTRACT_INVARIANT(...) /** Program volatile class invariants that can be completely disabled at compile-time. @c BOOST_CONTRACT_INVARIANT_VOLATILE({ ... }) expands to code equivalent to the following (note that no code is generated when @RefMacro{BOOST_CONTRACT_NO_INVARIANTS} is defined): @code #ifndef BOOST_CONTRACT_NO_INVARIANTS void BOOST_CONTRACT_INVARIANT_FUNC() const volatile { ... } #endif @endcode Where: @arg <b>{ ... }</b> is the definition of the function that checks class invariants for volatile public functions (see @RefMacro{BOOST_CONTRACT_INVARIANT} and @RefMacro{BOOST_CONTRACT_STATIC_INVARIANT}). The curly parenthesis are mandatory. Assertions within this function are usually programmed using @RefMacro{BOOST_CONTRACT_ASSERT}, but any exception thrown by a call to this function indicates a contract assertion failure (and will result in this library calling either @RefFunc{boost::contract::entry_invariant_failure} or @RefFunc{boost::contract::exit_invariant_failure}). (This is a variadic macro parameter so it can contain commas not protected by round parenthesis.) @see @RefSect{extras.disable_contract_compilation__macro_interface_, Disable Contract Compilation}, @RefSect{extras.volatile_public_functions, Volatile Public Functions} */ #define BOOST_CONTRACT_INVARIANT_VOLATILE(...) /** Program static class invariants that can be completely disabled at compile-time. @c BOOST_CONTRACT_STATIC_INVARIANT({ ... }) expands to code equivalent to the following (note that no code is generated when @RefMacro{BOOST_CONTRACT_NO_INVARIANTS} is defined): @code #ifndef BOOST_CONTRACT_NO_INVARIANTS static void BOOST_CONTRACT_STATIC_INVARIANT_FUNC() { ... } #endif @endcode Where: @arg <b>{ ... }</b> is the definition of the function that checks class invariants for static public functions (see @RefMacro{BOOST_CONTRACT_INVARIANT} and @RefMacro{BOOST_CONTRACT_INVARIANT_VOLATILE}). The curly parenthesis are mandatory. Assertions within this function are usually programmed using @RefMacro{BOOST_CONTRACT_ASSERT}, but any exception thrown by a call to this function indicates a contract assertion failure (and will result in this library calling either @RefFunc{boost::contract::entry_invariant_failure} or @RefFunc{boost::contract::exit_invariant_failure}). (This is a variadic macro parameter so it can contain commas not protected by round parenthesis.) @see @RefSect{extras.disable_contract_compilation__macro_interface_, Disable Contract Compilation}, @RefSect{tutorial.class_invariants, Class Invariants} */ #define BOOST_CONTRACT_STATIC_INVARIANT(...) #elif !defined(BOOST_CONTRACT_NO_INVARIANTS) #include <boost/contract/core/config.hpp> #define BOOST_CONTRACT_INVARIANT(...) \ void BOOST_CONTRACT_INVARIANT_FUNC() const __VA_ARGS__ #define BOOST_CONTRACT_INVARIANT_VOLATILE(...) \ void BOOST_CONTRACT_INVARIANT_FUNC() const volatile __VA_ARGS__ #define BOOST_CONTRACT_STATIC_INVARIANT(...) \ static void BOOST_CONTRACT_STATIC_INVARIANT_FUNC() __VA_ARGS__ #else #define BOOST_CONTRACT_INVARIANT(...) /* nothing */ #define BOOST_CONTRACT_INVARIANT_VOLATILE(...) /* nothing */ #define BOOST_CONTRACT_STATIC_INVARIANT(...) /* nothing */ #endif #ifdef BOOST_CONTRACT_DETAIL_DOXYGEN /** Program contracts that can be completely disabled at compile-time for constructors. This is used together with @RefMacro{BOOST_CONTRACT_POSTCONDITION}, @RefMacro{BOOST_CONTRACT_EXCEPT}, and @RefMacro{BOOST_CONTRACT_OLD} to specify postconditions, exception guarantees, and old value copies at body that can be completely disabled at compile-time for constructors (see @RefMacro{BOOST_CONTRACT_CONSTRUCTOR_PRECONDITION} to specify preconditions for constructors): @code class u { friend class boost::contract::access; BOOST_CONTRACT_INVARIANT({ // Optional (as for static and volatile). BOOST_CONTRACT_ASSERT(...); ... }) public: u(...) { BOOST_CONTRACT_OLD_PTR(old_type)(old_var); BOOST_CONTRACT_CONSTRUCTOR(this) // No `PRECONDITION` (use `CONSTRUCTOR_PRECONDITION` if needed). BOOST_CONTRACT_OLD([&] { // Optional. old_var = BOOST_CONTRACT_OLDOF(old_epxr); ... }) BOOST_CONTRACT_POSTCONDITION([&] { // Optional. BOOST_CONTRACT_ASSERT(...); ... }) BOOST_CONTRACT_EXCEPT([&] { // Optional. BOOST_CONTRACT_ASSERT(...); ... }) ; // Trailing `;` is required. ... // Constructor body. } ... }; @endcode For optimization, this can be omitted for constructors that do not have postconditions and exception guarantees, within classes that have no invariants. @c BOOST_CONTRACT_CONSTRUCTOR(obj) expands to code equivalent to the following (note that no code is generated when @RefMacro{BOOST_CONTRACT_NO_CONSTRUCTORS} is defined): @code #ifndef BOOST_CONTRACT_NO_CONSTRUCTORS boost::contract::check internal_var = boost::contract::constructor(obj) #endif @endcode Where: @arg <c><b>obj</b></c> is the object @c this from the scope of the enclosing constructor declaring the contract. Constructors check all class invariants, including static and volatile invariants (see @RefMacro{BOOST_CONTRACT_INVARIANT}, @RefMacro{BOOST_CONTRACT_STATIC_INVARIANT}, and @RefMacro{BOOST_CONTRACT_INVARIANT_VOLATILE}). (This is a variadic macro parameter so it can contain commas not protected by round parenthesis.) @arg <c><b>internal_var</b></c> is a variable name internally generated by this library (this name is unique but only on different line numbers so this macro cannot be expanded multiple times on the same line). @see @RefSect{extras.disable_contract_compilation__macro_interface_, Disable Contract Compilation}, @RefSect{tutorial.constructors, Constructors} */ #define BOOST_CONTRACT_CONSTRUCTOR(...) #elif !defined(BOOST_CONTRACT_NO_CONSTRUCTORS) #include <boost/contract/constructor.hpp> #include <boost/contract/check.hpp> #include <boost/contract/detail/name.hpp> #define BOOST_CONTRACT_CONSTRUCTOR(...) \ boost::contract::check BOOST_CONTRACT_DETAIL_NAME2(c, __LINE__) = \ boost::contract::constructor(__VA_ARGS__) #else #define BOOST_CONTRACT_CONSTRUCTOR(...) /* nothing */ #endif #ifdef BOOST_CONTRACT_DETAIL_DOXYGEN /** Program preconditions that can be disabled at compile-time for constructors. This is used together with @RefMacro{BOOST_CONTRACT_CONSTRUCTOR} to specify contracts for constructors. Constructors that do not have preconditions do not use this macro. When at least one of the class constructors uses this macro, @RefClass{boost::contract::constructor_precondition} must be the first and private base of the class declaring the constructor for which preconditions are programmed: @code class u #define BASES private boost::contract::constructor_precondition<u>, \ public b : BASES { friend class boost::contract::access; typedef BOOST_CONTRACT_BASE_TYPES(BASES) base_types; #undef BASES ... public: explicit u(unsigned x) : BOOST_CONTRACT_CONSTRUCTOR_PRECONDITION(u)([&] { BOOST_CONTRACT_ASSERT(x != 0); }), b(1 / x) { ... } ... }; @endcode <c>BOOST_CONTRACT_CONSTRUCTOR_PRECONDITION(class_type)(f)</c> expands to code equivalent to the following (note that when @RefMacro{BOOST_CONTRACT_NO_PRECONDITIONS} is defined, this macro trivially expands to a default constructor call that is internally implemented to do nothing so this should have minimal to no overhead): @code // Guarded only by NO_PRECONDITIONS (and not also by NO_CONSTRUCTORS) // because for constructor's preconditions (not for postconditions, etc.). #ifndef BOOST_CONTRACT_NO_PRECONDITIONS boost::contract::constructor_precondition<class_type>(f) #else // No-op call (likely optimized away, minimal to no overhead). boost::contract::constructor_precondition<class_type>() #endif @endcode Where: @arg <c><b>class_type</b></c> is the type of the class containing the constructor for which preconditions are being programmed. (This is a variadic macro parameter so it can contain commas not protected by round parenthesis.) @arg <c><b>f</b></c> is the nullary functor called by this library to check constructor preconditions @c f(). Assertions within this functor call are usually programmed using @RefMacro{BOOST_CONTRACT_ASSERT}, but any exception thrown by a call to this functor indicates a contract failure (and will result in this library calling @RefFunc{boost::contract::precondition_failure}). This functor should capture variables by (constant) value, or better by (constant) reference to avoid extra copies. (This is a variadic macro parameter so it can contain commas not protected by round parenthesis.) @see @RefSect{extras.disable_contract_compilation__macro_interface_, Disable Contract Compilation}, @RefSect{tutorial.constructors, Constructors} */ #define BOOST_CONTRACT_CONSTRUCTOR_PRECONDITION(...) #elif !defined(BOOST_CONTRACT_NO_PRECONDITIONS) // Not NO_CONSTRUCTORS here. // constructor_precondition.hpp already #included at top. #define BOOST_CONTRACT_CONSTRUCTOR_PRECONDITION(...) \ boost::contract::constructor_precondition< __VA_ARGS__ > #else #include <boost/preprocessor/tuple/eat.hpp> // constructor_precondition.hpp always #included at top of this file. #define BOOST_CONTRACT_CONSTRUCTOR_PRECONDITION(...) \ /* always use default ctor (i.e., do nothing) */ \ boost::contract::constructor_precondition< __VA_ARGS__ >() \ BOOST_PP_TUPLE_EAT(0) #endif #ifdef BOOST_CONTRACT_DETAIL_DOXYGEN /** Program contracts that can be completely disabled at compile-time for destructors. This is used together with @RefMacro{BOOST_CONTRACT_POSTCONDITION}, @RefMacro{BOOST_CONTRACT_EXCEPT}, and @RefMacro{BOOST_CONTRACT_OLD} to specify postconditions, exception guarantees, and old value copies at body that can be completely disabled at compile-time for destructors (destructors cannot have preconditions, see @RefSect{contract_programming_overview.destructor_calls, Destructor Calls}): @code class u { friend class boost::contract::access; BOOST_CONTRACT_INVARIANT({ // Optional (as for static and volatile). BOOST_CONTRACT_ASSERT(...); ... }) public: ~u() { BOOST_CONTRACT_OLD_PTR(old_type)(old_var); BOOST_CONTRACT_DESTRUCTOR(this) // No `PRECONDITION` (destructors have no preconditions). BOOST_CONTRACT_OLD([&] { // Optional. old_var = BOOST_CONTRACT_OLDOF(old_expr); ... }) BOOST_CONTRACT_POSTCONDITION([&] { // Optional. BOOST_CONTRACT_ASSERT(...); ... }) BOOST_CONTRACT_EXCEPT([&] { // Optional. BOOST_CONTRACT_ASSERT(...); ... }) ; // Trailing `;` is required. ... // Destructor body. } ... }; @endcode For optimization, this can be omitted for destructors that do not have postconditions and exception guarantees, within classes that have no invariants. @c BOOST_CONTRACT_DESTRUCTOR(obj) expands to code equivalent to the following (note that no code is generated when @RefMacro{BOOST_CONTRACT_NO_DESTRUCTORS} is defined): @code #ifndef BOOST_CONTRACT_NO_DESTRUCTORS boost::contract::check internal_var = boost::contract::destructor(obj) #endif @endcode Where: @arg <c><b>obj</b></c> is the object @c this from the scope of the enclosing destructor declaring the contract. Destructors check all class invariants, including static and volatile invariants (see @RefSect{tutorial.class_invariants, Class Invariants} and @RefSect{extras.volatile_public_functions, Volatile Public Functions}). (This is a variadic macro parameter so it can contain commas not protected by round parenthesis.) @arg <c><b>internal_var</b></c> is a variable name internally generated by this library (this name is unique but only on different line numbers so this macro cannot be expanded multiple times on the same line). @see @RefSect{extras.disable_contract_compilation__macro_interface_, Disable Contract Compilation}, @RefSect{tutorial.destructors, Destructors} */ #define BOOST_CONTRACT_DESTRUCTOR(...) #elif !defined(BOOST_CONTRACT_NO_DESTRUCTORS) #include <boost/contract/destructor.hpp> #include <boost/contract/check.hpp> #include <boost/contract/detail/name.hpp> #define BOOST_CONTRACT_DESTRUCTOR(...) \ boost::contract::check BOOST_CONTRACT_DETAIL_NAME2(c, __LINE__) = \ boost::contract::destructor(__VA_ARGS__) #else #define BOOST_CONTRACT_DESTRUCTOR(...) /* nothing */ #endif #ifdef BOOST_CONTRACT_DETAIL_DOXYGEN /** Program contracts that can be completely disabled at compile-time for (non-public) functions. This is used together with @RefMacro{BOOST_CONTRACT_PRECONDITION}, @RefMacro{BOOST_CONTRACT_POSTCONDITION}, @RefMacro{BOOST_CONTRACT_EXCEPT}, and @RefMacro{BOOST_CONTRACT_OLD} to specify preconditions, postconditions, exception guarantees, and old value copies at body that can be completely disabled at compile-time for (non-public) functions: @code void f(...) { BOOST_CONTRACT_OLD_PTR(old_type)(old_var); BOOST_CONTRACT_FUNCTION() BOOST_CONTRACT_PRECONDITION([&] { // Optional. BOOST_CONTRACT_ASSERT(...); ... }) BOOST_CONTRACT_OLD([&] { // Optional. old_var = BOOST_CONTRACT_OLDOF(old_expr); ... }) BOOST_CONTRACT_POSTCONDITION([&] { // Optional. BOOST_CONTRACT_ASSERT(...); ... }) BOOST_CONTRACT_EXCEPT([&] { // Optional. BOOST_CONTRACT_ASSERT(...); ... }) ; // Trailing `;` is required. ... // Function body. } @endcode This can be used to program contracts for non-member functions but also for private and protected functions, lambda functions, loops, arbitrary blocks of code, etc. For optimization, this can be omitted for code that does not have preconditions, postconditions, and exception guarantees. @c BOOST_CONTRACT_FUNCTION() expands to code equivalent to the following (note that no code is generated when @RefMacro{BOOST_CONTRACT_NO_FUNCTIONS} is defined): @code #ifndef BOOST_CONTRACT_NO_FUNCTIONS boost::contract::check internal_var = boost::contract::function() #endif @endcode Where: @arg <c><b>internal_var</b></c> is a variable name internally generated by this library (this name is unique but only on different line numbers so this macro cannot be expanded multiple times on the same line). @see @RefSect{extras.disable_contract_compilation__macro_interface_, Disable Contract Compilation}, @RefSect{tutorial.non_member_functions, Non-Member Functions}, @RefSect{advanced.private_and_protected_functions, Private and Protected Functions}, @RefSect{advanced.lambdas__loops__code_blocks__and__constexpr__, Lambdas\, Loops\, Code Blocks} */ #define BOOST_CONTRACT_FUNCTION() #elif !defined(BOOST_CONTRACT_NO_FUNCTIONS) #include <boost/contract/function.hpp> #include <boost/contract/check.hpp> #include <boost/contract/detail/name.hpp> #define BOOST_CONTRACT_FUNCTION() \ boost::contract::check BOOST_CONTRACT_DETAIL_NAME2(c, __LINE__) = \ boost::contract::function() #else #include <boost/preprocessor/facilities/empty.hpp> #define BOOST_CONTRACT_FUNCTION() /* nothing */ #endif #ifdef BOOST_CONTRACT_DETAIL_DOXYGEN /** Program contracts that can be completely disabled at compile-time for static public functions. This is used together with @RefMacro{BOOST_CONTRACT_PRECONDITION}, @RefMacro{BOOST_CONTRACT_POSTCONDITION}, @RefMacro{BOOST_CONTRACT_EXCEPT}, and @RefMacro{BOOST_CONTRACT_OLD} to specify preconditions, postconditions, exception guarantees, and old value copies at body that can be completely disabled at compile-time for static public functions: @code class u { friend class boost::contract::access; BOOST_CONTRACT_STATIC_INVARIANT({ // Optional (as for non-static). BOOST_CONTRACT_ASSERT(...); ... }) public: static void f(...) { BOOST_CONTRACT_OLD_PTR(old_type)(old_var); BOOST_CONTRACT_PUBLIC_FUNCTION(u) BOOST_CONTRACT_PRECONDITION([&] { // Optional. BOOST_CONTRACT_ASSERT(...); ... }) BOOST_CONTRACT_OLD([&] { // Optional. old_var = BOOST_CONTRACT_OLDOF(old_expr); ... }) BOOST_CONTRACT_POSTCONDITION([&] { // Optional. BOOST_CONTRACT_ASSERT(...); ... }) BOOST_CONTRACT_EXCEPT([&] { // Optional. BOOST_CONTRACT_ASSERT(...); ... }) ; // Trailing `;` is required. ... // Function body. } ... }; @endcode For optimization, this can be omitted for static public functions that do not have preconditions, postconditions and exception guarantees, within classes that have no static invariants. @c BOOST_CONTRACT_STATIC_PUBLIC_FUNCTION(class_type) expands to code equivalent to the following (note that no code is generated when @RefMacro{BOOST_CONTRACT_NO_PUBLIC_FUNCTIONS} is defined): @code #ifndef BOOST_CONTRACT_NO_PUBLIC_FUNCTIONS boost::contract::check internal_var = boost::contract::public_function<class_type>() #endif @endcode Where: @arg <c><b>class_type</b></c> is the type of the class containing the static public function declaring the contract. (This is a variadic macro parameter so it can contain commas not protected by round parenthesis.) @arg <c><b>internal_var</b></c> is a variable name internally generated by this library (this name is unique but only on different line numbers so this macro cannot be expanded multiple times on the same line). @see @RefSect{extras.disable_contract_compilation__macro_interface_, Disable Contract Compilation}, @RefSect{tutorial.static_public_functions, Static Public Functions} */ #define BOOST_CONTRACT_STATIC_PUBLIC_FUNCTION(...) /** Program contracts that can be completely disabled at compile-time for non-static public functions that do not override. This is used together with @RefMacro{BOOST_CONTRACT_PRECONDITION}, @RefMacro{BOOST_CONTRACT_POSTCONDITION}, @RefMacro{BOOST_CONTRACT_EXCEPT}, and @RefMacro{BOOST_CONTRACT_OLD} to specify preconditions, postconditions, exception guarantees, and old value copies at body that can be completely disabled at compile-time for non-static public functions (virtual or not, void or not) that do not override: @code class u { friend class boost::contract::access; BOOST_CONTRACT_INVARIANT({ // Optional (as for static and volatile). BOOST_CONTRACT_ASSERT(...); ... }) public: // Non-virtual (same if void). t f(...) { t result; BOOST_CONTRACT_OLD_PTR(old_type)(old_var); BOOST_CONTRACT_PUBLIC_FUNCTION(this) BOOST_CONTRACT_PRECONDITION([&] { // Optional. BOOST_CONTRACT_ASSERT(...); ... }) BOOST_CONTRACT_OLD([&] { // Optional. old_var = BOOST_CONTRACT_OLDOF(old_expr); ... }) BOOST_CONTRACT_POSTCONDITION([&] { // Optional. BOOST_CONTRACT_ASSERT(...); ... }) BOOST_CONTRACT_EXCEPT([&] { // Optional. BOOST_CONTRACT_ASSERT(...); ... }) ; // Trailing `;` is required. ... // Function body (use `return result = return_expr`). } // Virtual and void. virtual void g(..., boost::contract::virtual_* v = 0) { BOOST_CONTRACT_OLD_PTR(old_type)(old_var); BOOST_CONTRACT_PUBLIC_FUNCTION(v, this) ... BOOST_CONTRACT_OLD([&] { // Optional. old_var = BOOST_CONTRACT_OLDOF(v, old_expr); ... }) ... ; // Trailing `;` is required. ... // Function body. } // Virtual and non-void. virtual t h(..., boost::contract::virtual_* v = 0) { t result; BOOST_CONTRACT_OLD_PTR(old_type)(old_var); BOOST_CONTRACT_PUBLIC_FUNCTION(v, result, this) ... BOOST_CONTRACT_OLD([&] { // Optional. old_var = BOOST_CONTRACT_OLDOF(v, old_expr); ... }) BOOST_CONTRACT_POSTCONDITION([&] (t const& result) { // Optional BOOST_CONTRACT_ASSERT(...); ... }) ... ; // Trailing `;` is required. ... // Function body (use `return result = return_expr`). } ... }; @endcode For optimization, this can be omitted for non-virtual public functions that do not have preconditions, postconditions and exception guarantees, within classes that have no invariants. Virtual public functions should always use @RefMacro{BOOST_CONTRACT_PUBLIC_FUNCTION} otherwise this library will not be able to correctly use them for subcontracting. This is an overloaded variadic macro and it can be used in the following different ways (note that no code is generated when @RefMacro{BOOST_CONTRACT_NO_PUBLIC_FUNCTIONS} is defined). 1\. <c>BOOST_CONTRACT_PUBLIC_FUNCTION(obj)</c> expands to code equivalent to the following (for non-virtual public functions that are not static and do not override, returning void or not): @code #ifndef BOOST_CONTRACT_NO_PUBLIC_FUNCTIONS boost::contract::check internal_var = boost::contract::public_function(obj) #endif @endcode 2\. <c>BOOST_CONTRACT_PUBLIC_FUNCTION(v, obj)</c> expands to code equivalent to the following (for virtual public functions that do not override, returning void): @code #ifndef BOOST_CONTRACT_NO_PUBLIC_FUNCTIONS boost::contract::check internal_var = boost::contract::public_function(v, obj) #endif @endcode 3\. <c>BOOST_CONTRACT_PUBLIC_FUNCTION(v, r, obj)</c> expands to code equivalent to the following (for virtual public functions that do not override, not returning void): @code #ifndef BOOST_CONTRACT_NO_PUBLIC_FUNCTIONS boost::contract::check internal_var = boost::contract::public_function(v, r, obj) #endif @endcode Where (these are all variadic macro parameters so they can contain commas not protected by round parenthesis): @arg <c><b>v</b></c> is the extra parameter of type @RefClass{boost::contract::virtual_}<c>*</c> and default value @c 0 from the enclosing virtual public function declaring the contract. @arg <c><b>r</b></c> is a reference to the return value of the enclosing virtual public function declaring the contract. This is usually a local variable declared by the enclosing virtual public function just before the contract, but programmers must set it to the actual value being returned by the function at each @c return statement. @arg <c><b>obj</b></c> is the object @c this from the scope of the enclosing public function declaring the contract. This object might be mutable, @c const, @c volatile, or <c>const volatile</c> depending on the cv-qualifier of the enclosing function (volatile public functions will check volatile class invariants, see @RefSect{extras.volatile_public_functions, Volatile Public Functions}). @arg <c><b>internal_var</b></c> is a variable name internally generated by this library (this name is unique but only on different line numbers so this macro cannot be expanded multiple times on the same line). @see @RefSect{extras.disable_contract_compilation__macro_interface_, Disable Contract Compilation}, @RefSect{tutorial.public_functions, Public Functions}, @RefSect{tutorial.virtual_public_functions, Virtual Public Functions} */ #define BOOST_CONTRACT_PUBLIC_FUNCTION(...) /** Program contracts that can be completely disabled at compile-time for public function overrides. This is used together with @RefMacro{BOOST_CONTRACT_PRECONDITION}, @RefMacro{BOOST_CONTRACT_POSTCONDITION}, @RefMacro{BOOST_CONTRACT_EXCEPT}, and @RefMacro{BOOST_CONTRACT_OLD} to specify preconditions, postconditions, exception guarantees, and old value copies at body that can be completely disabled at compile-time for public function overrides (virtual or not): @code class u #define BASES private boost::contract::constructor_precondition<u>, \ public b, private w : BASES { friend class boost::contract::access; typedef BOOST_CONTRACT_BASE_TYPES(BASES) base_types; #undef BASES BOOST_CONTRACT_INVARIANT({ // Optional (as for static and volatile). BOOST_CONTRACT_ASSERT(...); ... }) BOOST_CONTRACT_OVERRIDES(f, g) public: // Override from `b::f`, and void. void f(t_1 a_1, ..., t_n a_n, boost::contract::virtual_* v = 0) { BOOST_CONTRACT_OLD_PTR(old_type)(old_var); BOOST_CONTRACT_PUBLIC_FUNCTION_OVERRIDE(override_f)( v, &u::f, this, a_1, ..., a_n) BOOST_CONTRACT_PRECONDITION([&] { // Optional. BOOST_CONTRACT_ASSERT(...); ... }) BOOST_CONTRACT_OLD([&] { // Optional. old_var = BOOST_CONTRACT_OLDOF(v, old_expr); ... }) BOOST_CONTRACT_POSTCONDITION([&] { // Optional. BOOST_CONTRACT_ASSERT(...); ... }) BOOST_CONTRACT_EXCEPT([&] { // Optional. BOOST_CONTRACT_ASSERT(...); ... }) ; // Trailing `;` is required. ... // Function body. } // Override from `b::g`, and void. t g(t_1 a_1, ..., t_n a_n, boost::contract::virtual_* v = 0) { t result; BOOST_CONTRACT_OLD_PTR(old_type)(old_var); BOOST_CONTRACT_PUBLIC_FUNCTION_OVERRIDE(override_g)( v, result, &u::g, this, a_1, ..., a_n) ... BOOST_CONTRACT_OLD([&] { // Optional. old_var = BOOST_CONTRACT_OLDOF(v, old_expr); ... }) BOOST_CONTRACT_POSTCONDITION([&] (t const& result) { // Optional BOOST_CONTRACT_ASSERT(...); ... }) ... ; // Trailing `;` is required. ... // Function body (use `return result = return_expr`). } ... }; @endcode Public function overrides should always use @RefMacro{BOOST_CONTRACT_PUBLIC_FUNCTION_OVERRIDE} otherwise this library will not be able to correctly use it for subcontracting. This is an overloaded variadic macro and it can be used in the following different ways (note that no code is generated when @RefMacro{BOOST_CONTRACT_NO_PUBLIC_FUNCTIONS} is defined). 1\. <c>BOOST_CONTRACT_PUBLIC_FUNCTION_OVERRIDE(override_type)(v, f, obj, ...)</c> expands to code equivalent to the following (for public function overrides that return void): @code #ifndef BOOST_CONTRACT_NO_PUBLIC_FUNCTIONS boost::contract::check internal_var = boost::contract:: public_function<override_type>(v, f, obj, ...) #endif @endcode 2\. <c>BOOST_CONTRACT_PUBLIC_FUNCTION_OVERRIDE(override_type)(v, r, f, obj, ...)</c> expands to code equivalent to the following (for public function overrides that do not return void): @code #ifndef BOOST_CONTRACT_NO_PUBLIC_FUNCTIONS boost::contract::check internal_var = boost::contract:: public_function<override_type>(v, r, f, obj, ...) #endif @endcode Where (these are all variadic macro parameters so they can contain commas not protected by round parenthesis): @arg <c><b>override_type</b></c> is the type <c>override_<i>function-name</i></c> declared using the @RefMacro{BOOST_CONTRACT_OVERRIDE} or related macros. @arg <c><b>v</b></c> is the extra parameter of type @RefClass{boost::contract::virtual_}<c>*</c> and default value @c 0 from the enclosing virtual public function declaring the contract. @arg <c><b>r</b></c> is a reference to the return value of the enclosing virtual public function declaring the contract. This is usually a local variable declared by the enclosing virtual public function just before the contract, but programmers must set it to the actual value being returned by the function at each @c return statement. @arg <c><b>f</b></c> is a pointer to the enclosing public function override declaring the contract. @arg <c><b>obj</b></c> is the object @c this from the scope of the enclosing public function declaring the contract. This object might be mutable, @c const, @c volatile, or <c>const volatile</c> depending on the cv-qualifier of the enclosing function (volatile public functions will check volatile class invariants, see @RefSect{extras.volatile_public_functions, Volatile Public Functions}). @arg <c><b>...</b></c> is a variadic macro parameter listing all the arguments passed to the enclosing public function override declaring the contract (by reference and in the order they appear in the enclosing function declaration), but excluding the trailing argument @c v. @arg <c><b>internal_var</b></c> is a variable name internally generated by this library (this name is unique but only on different line numbers so this macro cannot be expanded multiple times on the same line). @see @RefSect{extras.disable_contract_compilation__macro_interface_, Disable Contract Compilation}, @RefSect{tutorial.public_function_overrides__subcontracting_, Public Function Overrides} */ #define BOOST_CONTRACT_PUBLIC_FUNCTION_OVERRIDE(...) #elif !defined(BOOST_CONTRACT_NO_PUBLIC_FUNCTIONS) #include <boost/contract/public_function.hpp> #include <boost/contract/check.hpp> #include <boost/contract/detail/name.hpp> #define BOOST_CONTRACT_STATIC_PUBLIC_FUNCTION(...) \ boost::contract::check BOOST_CONTRACT_DETAIL_NAME2(c, __LINE__) = \ boost::contract::public_function< __VA_ARGS__ >() #define BOOST_CONTRACT_PUBLIC_FUNCTION(...) \ boost::contract::check BOOST_CONTRACT_DETAIL_NAME2(c, __LINE__) = \ boost::contract::public_function(__VA_ARGS__) #define BOOST_CONTRACT_PUBLIC_FUNCTION_OVERRIDE(...) \ boost::contract::check BOOST_CONTRACT_DETAIL_NAME2(c, __LINE__) = \ boost::contract::public_function<__VA_ARGS__> #else #include <boost/preprocessor/tuple/eat.hpp> #define BOOST_CONTRACT_STATIC_PUBLIC_FUNCTION(...) /* nothing */ #define BOOST_CONTRACT_PUBLIC_FUNCTION(...) /* nothing */ #define BOOST_CONTRACT_PUBLIC_FUNCTION_OVERRIDE(...) BOOST_PP_TUPLE_EAT(0) #endif #endif // #include guard