summaryrefslogtreecommitdiff
path: root/boost/contract_macro.hpp
diff options
context:
space:
mode:
Diffstat (limited to 'boost/contract_macro.hpp')
-rw-r--r--boost/contract_macro.hpp1397
1 files changed, 1397 insertions, 0 deletions
diff --git a/boost/contract_macro.hpp b/boost/contract_macro.hpp
new file mode 100644
index 0000000000..8bfa7c84eb
--- /dev/null
+++ b/boost/contract_macro.hpp
@@ -0,0 +1,1397 @@
+
+#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 also includes all headers file <c>boost/contract/\*.hpp</c> that are
+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(...)</c>.
+ 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>) as
+ its one single parameter but only for virtual public functions and
+ public functions overrides, otherwise it takes no parameter.
+ (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_value_copies_at_body,
+ Old Value Copies at Body}
+ */
+ #define BOOST_CONTRACT_OLD(...)
+
+ /**
+ Program old values that can be completely disabled at compile-time and
+ require the old value type 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);
+ BOOST_CONTRACT_OLD_PTR(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);
+ ...
+ })
+ ...
+ ;
+
+ ... // Function body.
+ }
+
+ virtual void g(..., boost::contract::virtual_* v = 0) {
+ BOOST_CONTRACT_OLD_PTR(old_type_a)(old_var_a);
+ BOOST_CONTRACT_OLD_PTR(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);
+ ...
+ })
+ ...
+ ;
+
+ ... // 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.)
+ @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 or public function
+ override declaring the contract.
+ (This is not a variadic macro parameter.)
+ @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,
+ <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 and do
+ not require the old value type 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 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.)
+ @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,
+ <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.
+ 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(...);
+ ...
+ })
+ ;
+
+ ... // 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 class 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
+ {
+ ...
+ #undef BASES
+
+ public:
+ explicit u(unsigned x) :
+ BOOST_CONTRACT_CONSTRUCTOR_PRECONDITION(u)([&] {
+ BOOST_CONTRACT_ASSERT(x != 0);
+ }),
+ b(1.0 / float(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(...);
+ ...
+ })
+ ;
+
+ ... // 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(...);
+ ...
+ })
+ ;
+
+ ... // 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(...);
+ ...
+ })
+ ;
+
+ ... // 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(...);
+ ...
+ })
+ ;
+
+ ... // 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);
+ ...
+ })
+ ...
+ ;
+
+ ... // 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(...);
+ ...
+ })
+ ...
+ ;
+
+ ... // 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 are
+ not static and 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 are
+ not static and 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(...);
+ ...
+ })
+ ;
+
+ ... // 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(...);
+ ...
+ })
+ ...
+ ;
+
+ ... // 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 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
+